mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
128 lines
3.4 KiB
C++
128 lines
3.4 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=2 et sw=2 tw=80: */
|
|
/* 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/RefPtr.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsIEventTarget.h"
|
|
#include "nsThreadUtils.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() { 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 };
|
|
enum Mode { STREAM, DGRAM };
|
|
|
|
// Is this a stream or datagram flow
|
|
TransportLayer(Mode mode = STREAM) :
|
|
mode_(mode),
|
|
state_(TS_NONE),
|
|
flow_(nullptr),
|
|
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_; }
|
|
|
|
// Dispatch a call onto our thread (or run on the same thread if
|
|
// thread is not set). This is always synchronous.
|
|
nsresult RunOnThread(nsIRunnable *event) {
|
|
if (target_) {
|
|
nsIThread *thr;
|
|
|
|
nsresult rv = NS_GetCurrentThread(&thr);
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
|
|
|
if (target_ != thr) {
|
|
return target_->Dispatch(event, NS_DISPATCH_SYNC);
|
|
}
|
|
}
|
|
|
|
return event->Run();
|
|
}
|
|
|
|
// 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;
|
|
|
|
// 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() = 0;
|
|
|
|
// The id of the flow
|
|
virtual const std::string& flow_id();
|
|
|
|
protected:
|
|
virtual void WasInserted() {}
|
|
virtual void SetState(State state);
|
|
|
|
void CheckThread() {
|
|
NS_ABORT_IF_FALSE(CheckThreadInt(), "Wrong thread");
|
|
}
|
|
|
|
Mode mode_;
|
|
State state_;
|
|
TransportFlow *flow_; // The flow this is part of
|
|
TransportLayer *downward_; // The next layer in the stack
|
|
nsCOMPtr<nsIEventTarget> target_;
|
|
|
|
private:
|
|
DISALLOW_COPY_ASSIGN(TransportLayer);
|
|
|
|
bool CheckThreadInt() {
|
|
bool on;
|
|
NS_ENSURE_TRUE(target_, false);
|
|
NS_ENSURE_SUCCESS(target_->IsOnCurrentThread(&on), false);
|
|
NS_ENSURE_TRUE(on, false);
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
#define LAYER_INFO "Flow[" << flow_id() << "(none)" << "]; Layer[" << id() << "]: "
|
|
|
|
} // close namespace
|
|
#endif
|