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
|
// 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 DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_NET_H_
#define DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_NET_H_
#include <queue>
#include <string>
#include "base/basictypes.h"
#include "base/memory/linked_ptr.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/sequenced_task_runner.h"
#include "device/bluetooth/bluetooth_socket.h"
#include "device/bluetooth/bluetooth_socket_thread.h"
#include "net/base/net_log.h"
#include "net/socket/tcp_socket.h"
namespace net {
class IOBuffer;
class IOBufferWithSize;
} // namespace net
namespace device {
// This class is a base-class for implementations of BluetoothSocket that can
// use net::TCPSocket. All public methods (including the factory method) must
// be called on the UI thread, while underlying socket operations are
// performed on a separate thread.
class BluetoothSocketNet : public BluetoothSocket {
public:
// BluetoothSocket:
virtual void Close() OVERRIDE;
virtual void Disconnect(const base::Closure& callback) OVERRIDE;
virtual void Receive(int buffer_size,
const ReceiveCompletionCallback& success_callback,
const ReceiveErrorCompletionCallback& error_callback)
OVERRIDE;
virtual void Send(scoped_refptr<net::IOBuffer> buffer,
int buffer_size,
const SendCompletionCallback& success_callback,
const ErrorCompletionCallback& error_callback) OVERRIDE;
protected:
BluetoothSocketNet(scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
scoped_refptr<BluetoothSocketThread> socket_thread,
net::NetLog* net_log,
const net::NetLog::Source& source);
virtual ~BluetoothSocketNet();
// Resets locally held data after a socket is closed. Default implementation
// does nothing, subclasses may override.
virtual void ResetData();
// Methods for subclasses to obtain the members.
scoped_refptr<base::SequencedTaskRunner> ui_task_runner() const {
return ui_task_runner_;
}
scoped_refptr<BluetoothSocketThread> socket_thread() const {
return socket_thread_;
}
net::NetLog* net_log() const { return net_log_; }
const net::NetLog::Source& source() const { return source_; }
net::TCPSocket* tcp_socket() { return tcp_socket_.get(); }
void ResetTCPSocket();
void SetTCPSocket(scoped_ptr<net::TCPSocket> tcp_socket);
void PostSuccess(const base::Closure& callback);
void PostErrorCompletion(const ErrorCompletionCallback& callback,
const std::string& error);
private:
struct WriteRequest {
WriteRequest();
~WriteRequest();
scoped_refptr<net::IOBuffer> buffer;
int buffer_size;
SendCompletionCallback success_callback;
ErrorCompletionCallback error_callback;
};
void DoClose();
void DoDisconnect(const base::Closure& callback);
void DoReceive(int buffer_size,
const ReceiveCompletionCallback& success_callback,
const ReceiveErrorCompletionCallback& error_callback);
void OnSocketReadComplete(
const ReceiveCompletionCallback& success_callback,
const ReceiveErrorCompletionCallback& error_callback,
int read_result);
void DoSend(scoped_refptr<net::IOBuffer> buffer,
int buffer_size,
const SendCompletionCallback& success_callback,
const ErrorCompletionCallback& error_callback);
void SendFrontWriteRequest();
void OnSocketWriteComplete(const SendCompletionCallback& success_callback,
const ErrorCompletionCallback& error_callback,
int send_result);
void PostReceiveCompletion(const ReceiveCompletionCallback& callback,
int io_buffer_size,
scoped_refptr<net::IOBuffer> io_buffer);
void PostReceiveErrorCompletion(
const ReceiveErrorCompletionCallback& callback,
ErrorReason reason,
const std::string& error_message);
void PostSendCompletion(const SendCompletionCallback& callback,
int bytes_written);
scoped_refptr<base::SequencedTaskRunner> ui_task_runner_;
scoped_refptr<BluetoothSocketThread> socket_thread_;
net::NetLog* net_log_;
const net::NetLog::Source source_;
scoped_ptr<net::TCPSocket> tcp_socket_;
scoped_refptr<net::IOBufferWithSize> read_buffer_;
std::queue<linked_ptr<WriteRequest> > write_queue_;
DISALLOW_COPY_AND_ASSIGN(BluetoothSocketNet);
};
} // namespace device
#endif // DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_NET_H_
|
