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
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
// Original author: ekr@rtfm.com
#ifndef transportlayer_h__
#define transportlayer_h__
#include "sigslot.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/RefPtr.h"
#include "nsCOMPtr.h"
#include "nsIEventTarget.h"
#include "m_cpp_utils.h"
namespace mozilla {
class TransportFlow;
typedef int TransportResult;
enum {
TE_WOULDBLOCK = -1, TE_ERROR = -2, TE_INTERNAL = -3
};
#define TRANSPORT_LAYER_ID(name) \
virtual const std::string id() const { return name; } \
static std::string ID() { return name; }
// Abstract base class for network transport layers.
class TransportLayer : public sigslot::has_slots<> {
public:
// The state of the transport flow
// We can't use "ERROR" because Windows has a macro named "ERROR"
enum State { TS_NONE, TS_INIT, TS_CONNECTING, TS_OPEN, TS_CLOSED, TS_ERROR };
// Is this a stream or datagram flow
TransportLayer() :
state_(TS_NONE),
flow_id_(),
downward_(nullptr) {}
virtual ~TransportLayer() {}
// Called to initialize
nsresult Init(); // Called by Insert() to set up -- do not override
virtual nsresult InitInternal() { return NS_OK; } // Called by Init
// Called when inserted into a flow
virtual void Inserted(TransportFlow *flow, TransportLayer *downward);
// Downward interface
TransportLayer *downward() { return downward_; }
// Get the state
State state() const { return state_; }
// Must be implemented by derived classes
virtual TransportResult SendPacket(const unsigned char *data, size_t len) = 0;
// Get the thread.
const nsCOMPtr<nsIEventTarget> GetThread() const {
return target_;
}
// Event definitions that one can register for
// State has changed
sigslot::signal2<TransportLayer*, State> SignalStateChange;
// Data received on the flow
sigslot::signal3<TransportLayer*, const unsigned char *, size_t>
SignalPacketReceived;
// Return the layer id for this layer
virtual const std::string id() const = 0;
// The id of the flow
const std::string& flow_id() const {
return flow_id_;
}
protected:
virtual void WasInserted() {}
virtual void SetState(State state, const char *file, unsigned line);
// Check if we are on the right thread
void CheckThread() const {
MOZ_ASSERT(CheckThreadInt(), "Wrong thread");
}
State state_;
std::string flow_id_;
TransportLayer *downward_; // The next layer in the stack
nsCOMPtr<nsIEventTarget> target_;
private:
DISALLOW_COPY_ASSIGN(TransportLayer);
bool CheckThreadInt() const {
bool on;
if (!target_) // OK if no thread set.
return true;
NS_ENSURE_SUCCESS(target_->IsOnCurrentThread(&on), false);
NS_ENSURE_TRUE(on, false);
return true;
}
};
#define LAYER_INFO "Flow[" << flow_id() << "(none)" << "]; Layer[" << id() << "]: "
#define TL_SET_STATE(x) SetState((x), __FILE__, __LINE__)
} // close namespace
#endif
|
