dart::PortMap Class Reference

#include <port.h>

Inheritance diagram for dart::PortMap:

Static Public Member Functions
static Dart_Port	CreatePort (MessageHandler *handler)
static bool	ClosePort (Dart_Port id, MessageHandler **message_handler=nullptr)
static void	ClosePorts (MessageHandler *handler)
static bool	PostMessage (std::unique_ptr< Message > message, bool before_events=false)
static Isolate *	GetIsolate (Dart_Port id)
static Dart_Port	GetOriginId (Dart_Port id)
static bool	IsReceiverInThisIsolateGroupOrClosed (Dart_Port receiver, IsolateGroup *group)
static void	Init ()
static void	Cleanup ()
static void	PrintPortsForMessageHandler (MessageHandler *handler, JSONStream *stream)
static void	DebugDumpForMessageHandler (MessageHandler *handler)

Detailed Description

Definition at line 24 of file port.h.

Member Function Documentation

Cleanup()

void dart::PortMap::Cleanup ( )

static

Definition at line 261 of file port.cc.

                      {
  ASSERT(ports_ != nullptr);
  ASSERT(prng_ != nullptr);
  for (auto it = ports_->begin(); it != ports_->end(); ++it) {
    const auto& entry = *it;
    ASSERT(entry.handler != nullptr);
    delete entry.handler;
    it.Delete();
  }
  ports_->Rebalance();
 
  // Grab the mutex and delete the port set.
  MutexLocker ml(mutex_);
  delete prng_;
  prng_ = nullptr;
  delete ports_;
  ports_ = nullptr;
}

ClosePort()

bool dart::PortMap::ClosePort ( Dart_Port  id, MessageHandler **  message_handler = nullptr  )

static

Definition at line 90 of file port.cc.

                                                                        {
  if (message_handler != nullptr) *message_handler = nullptr;
 
  MessageHandler* handler = nullptr;
  {
    MutexLocker ml(mutex_);
    if (ports_ == nullptr) {
      return false;
    }
    auto it = ports_->TryLookup(port);
    if (it == ports_->end()) {
      return false;
    }
    Entry entry = *it;
    handler = entry.handler;
    ASSERT(handler != nullptr);
 
#if defined(DEBUG)
    handler->CheckAccess();
#endif
 
    // Delete the port entry before releasing the lock to avoid holding the lock
    // while flushing the messages below.
    it.Delete();
    ports_->Rebalance();
 
    // The MessageHandler::ports_ is only accessed by [PortMap], it is guarded
    // by the [PortMap::mutex_] we already hold.
    auto isolate_it = handler->ports_.TryLookup(port);
    ASSERT(isolate_it != handler->ports_.end());
    isolate_it.Delete();
    handler->ports_.Rebalance();
  }
  handler->ClosePort(port);
  if (message_handler != nullptr) *message_handler = handler;
  return true;
}

ClosePorts()

void dart::PortMap::ClosePorts ( MessageHandler *  handler )

static

Definition at line 128 of file port.cc.

                                                {
  {
    MutexLocker ml(mutex_);
    if (ports_ == nullptr) {
      return;
    }
    // The MessageHandler::ports_ is only accessed by [PortMap], it is guarded
    // by the [PortMap::mutex_] we already hold.
    for (auto isolate_it = handler->ports_.begin();
         isolate_it != handler->ports_.end(); ++isolate_it) {
      auto it = ports_->TryLookup((*isolate_it).port);
      ASSERT(it != ports_->end());
      Entry entry = *it;
      ASSERT(entry.port == (*isolate_it).port);
      ASSERT(entry.handler == handler);
      it.Delete();
      isolate_it.Delete();
    }
    ASSERT(handler->ports_.IsEmpty());
    ports_->Rebalance();
  }
  handler->CloseAllPorts();
}

CreatePort()

Dart_Port dart::PortMap::CreatePort ( MessageHandler *  handler )

static

Definition at line 55 of file port.cc.

                                                     {
  ASSERT(handler != nullptr);
  MutexLocker ml(mutex_);
  if (ports_ == nullptr) {
    return ILLEGAL_PORT;
  }
 
#if defined(DEBUG)
  handler->CheckAccess();
#endif
 
  const Dart_Port port = AllocatePort();
 
  // The MessageHandler::ports_ is only accessed by [PortMap], it is guarded
  // by the [PortMap::mutex_] we already hold.
  MessageHandler::PortSetEntry isolate_entry;
  isolate_entry.port = port;
  handler->ports_.Insert(isolate_entry);
 
  Entry entry;
  entry.port = port;
  entry.handler = handler;
  ports_->Insert(entry);
 
  if (FLAG_trace_isolates) {
    OS::PrintErr(
        "[+] Opening port: \n"
        "\thandler:    %s\n"
        "\tport:       %" Pd64 "\n",
        handler->name(), entry.port);
  }
 
  return entry.port;
}

DebugDumpForMessageHandler()

void dart::PortMap::DebugDumpForMessageHandler ( MessageHandler *  handler )

static

Definition at line 305 of file port.cc.

                                                                {
  SafepointMutexLocker ml(mutex_);
  if (ports_ == nullptr) {
    return;
  }
  Object& msg_handler = Object::Handle();
  for (auto& entry : *ports_) {
    if (entry.handler == handler) {
      OS::PrintErr("Port = %" Pd64 "\n", entry.port);
      msg_handler = DartLibraryCalls::LookupHandler(entry.port);
      OS::PrintErr("Handler = %s\n", msg_handler.ToCString());
    }
  }
}

GetIsolate()

Isolate * dart::PortMap::GetIsolate ( Dart_Port  id )

static

Definition at line 181 of file port.cc.

                                         {
  MutexLocker ml(mutex_);
  if (ports_ == nullptr) {
    return nullptr;
  }
  auto it = ports_->TryLookup(id);
  if (it == ports_->end()) {
    // Port does not exist.
    return nullptr;
  }
 
  MessageHandler* handler = (*it).handler;
  return handler->isolate();
}

GetOriginId()

Dart_Port dart::PortMap::GetOriginId ( Dart_Port  id )

static

Definition at line 196 of file port.cc.

                                           {
  MutexLocker ml(mutex_);
  if (ports_ == nullptr) {
    return ILLEGAL_PORT;
  }
  auto it = ports_->TryLookup(id);
  if (it == ports_->end()) {
    // Port does not exist.
    return ILLEGAL_PORT;
  }
 
  MessageHandler* handler = (*it).handler;
  Isolate* isolate = handler->isolate();
  if (isolate == nullptr) {
    // Message handler is a native port instead of an isolate.
    return ILLEGAL_PORT;
  }
  return isolate->origin_id();
}

Init()

void dart::PortMap::Init ( )

static

Definition at line 248 of file port.cc.

                   {
  if (mutex_ == nullptr) {
    mutex_ = new Mutex();
  }
  ASSERT(mutex_ != nullptr);
  if (prng_ == nullptr) {
    prng_ = new Random();
  }
  if (ports_ == nullptr) {
    ports_ = new PortSet<Entry>();
  }
}

IsReceiverInThisIsolateGroupOrClosed()

bool dart::PortMap::IsReceiverInThisIsolateGroupOrClosed ( Dart_Port  receiver, IsolateGroup *  group  )

static

Definition at line 228 of file port.cc.

                                                                        {
  MutexLocker ml(mutex_);
  if (ports_ == nullptr) {
    // Port was closed.
    return true;
  }
  auto it = ports_->TryLookup(receiver);
  if (it == ports_->end()) {
    // Port was closed.
    return true;
  }
  auto isolate = (*it).handler->isolate();
  if (isolate == nullptr) {
    // Port belongs to a native port instead of an isolate.
    return false;
  }
  return isolate->group() == group;
}

PostMessage()

bool dart::PortMap::PostMessage ( std::unique_ptr< Message >  message, bool  before_events = false  )

static

Definition at line 152 of file port.cc.

                                              {
  MutexLocker ml(mutex_);
  if (ports_ == nullptr) {
    return false;
  }
  auto it = ports_->TryLookup(message->dest_port());
  if (it == ports_->end()) {
    // Ownership of external data remains with the poster.
    message->DropFinalizers();
    return false;
  }
  MessageHandler* handler = (*it).handler;
  ASSERT(handler != nullptr);
  handler->PostMessage(std::move(message), before_events);
  return true;
}

PrintPortsForMessageHandler()

void dart::PortMap::PrintPortsForMessageHandler ( MessageHandler *  handler, JSONStream *  stream  )

static

Definition at line 280 of file port.cc.

                                                              {
#ifndef PRODUCT
  JSONObject jsobj(stream);
  jsobj.AddProperty("type", "_Ports");
  Object& msg_handler = Object::Handle();
  {
    JSONArray ports(&jsobj, "ports");
    SafepointMutexLocker ml(mutex_);
    if (ports_ == nullptr) {
      return;
    }
    for (auto& entry : *ports_) {
      if (entry.handler == handler) {
        JSONObject port(&ports);
        port.AddProperty("type", "_Port");
        port.AddPropertyF("name", "Isolate Port (%" Pd64 ")", entry.port);
        msg_handler = DartLibraryCalls::LookupHandler(entry.port);
        port.AddProperty("handler", msg_handler);
      }
    }
  }
#endif
}

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/port.h
• third_party/dart-lang/sdk/runtime/vm/port.cc