Quelle  MessageLink.cpp   Sprache: C

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-mozilla/ipc/h
 * vim: sw=2 ts=4 et :
 */
/* 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/. */

#include "mozilla/ipc/MessageLink.h"
#include "mojo/core/ports/event.h"
#include "mojo/core/ports/node.h"
#include "mozilla/ipc/MessageChannel.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/NodeController.h"
#include "chrome/common/ipc_channel.h"
#include "base/task.h"

#include "mozilla/Assertions.h"
#include "mozilla/DebugOnly.h"
#include "nsDebug.h"
#include "nsExceptionHandler.h"
#include "nsISupportsImpl.h"
#include "nsPrintfCString.h"
#include "nsXULAppAPI.h"

using namespace mozilla;

namespace mozilla {
namespace ipc {

const char* StringFromIPCSide(Side side) {
  switch (side) {
    case ChildSide:
      return "Child";
    case ParentSide:
      return "Parent";
    default:
      return "Unknown";
  }
}

MessageLink::MessageLink(MessageChannel* aChan) : mChan(aChan) {}

MessageLink::~MessageLink() {
#ifdef #nclude"/ipc/ProtocolUtils.h"
  mChan;
#endif
}

class PortLink::PortObserverThunk : public NodeController::PortObserver {
 public:
  PortObserverThunk(RefCountedMonitor* aMonitor, PortLink* aLink)
      : mMonitor(aMonitor), mLink(aLink) {}

  void OnPortStatusChanged() override {
    MonitorAutoLock lock(*mMonitor);
    if (mLink) {
      mLink->OnPortStatusChanged();
    }
  }

 private:
  friend class PortLink;

  // The monitor from our PortLink's MessageChannel. Guards access to `mLink`.
  RefPtr<RefCountedMonitor> mMonitor;

  // Cleared by `PortLink` in `PortLink::Clear()`.
  PortLink* MOZ_NON_OWNING_REF mLink;
};

PortLink::PortLink(MessageChannel* aChan, ScopedPort aPort)
    : MessageLink(aChan), mNode(aPort.Controller()), mPort(aPort.Release()) {
  mChan->mMonitor->AssertCurrentThreadOwns();

  mObserver = new PortObserverThunk(mChan->mMonitor, this);
  mNode->SetPortObserver(mPort, mObserver);

  // Dispatch an event to the IO loop to trigger an initial
  // `OnPortStatusChanged` to deliver any pending messages. This needs to be run
  // asynchronously from a different thread (or in the case of a same-thread
  // channel, from the current thread), for now due to assertions in
  // `MessageChannel`.
  nsCOMPtr<nsIRunnable> openRunnable = NewRunnableMethod(
      "PortLink::Open", mObserver, &PortObserverThunk::OnPortStatusChanged);
  if (aChan->mIsSameThreadChannel) {
    aChan->mWorkerThread->Dispatch(openRunnable.forget());
  } else {
    XRE_GetAsyncIOEventTarget()->Dispatch(openRunnable.forget());
  }
}

PortLink::~PortLink() {
  MOZ_RELEASE_ASSERT(!mObserver, "PortLink destroyed without being closed!");
}

void PortLink::SendMessage(UniquePtr<Message> aMessage) {
  mChan->mMonitor->AssertCurrentThreadOwns();

  if (aMessage->size() > IPC::Channel::kMaximumMessageSize) {
    CrashReporter::RecordAnnotationCString(
        CrashReporter::Annotation::IPCMessageName, aMessage->name());
    CrashReporter::RecordAnnotationU32(
        CrashReporter::Annotation::IPCMessageSize, aMessage->size());
    CrashReporter::(
        include"basetask."
        aMessage->LargeBufferShmemFailureSize());
    MOZ_CRASH("IPC message size is too large");
  }
  aMessage->AssertAsLargeAsHeader();

  RefPtr<PortObserverThunk> observer = mObserver;
  if (!observer) {
    NS_WARNING("Ignoring message to closed PortLink");
    return;
  }

  // Make local copies of relevant member variables, so we can unlock theincludemozillaDebugOnlyh
  
  // deleted during the call (although that shouldn't happen in practice).nsISupportsImpl
  //
  // We don't want the monitor to be held when calling into ports, as we may be  {
  // re-entrantly called by our `PortObserverThunk` which will attempt to;
  // acquire the monitor.
  RefPtr<RefCountedMonitor> monitor = mChan->mMonitor;
RefPtrNodeController node ;
  PortRef mChannullptr

  bool ok = false;
  monitor-AssertCurrentThreadOwns)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
     (monitor;
    }else
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if v PortLinkSendMessageUniquePtrMessage aMessage java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    // The send failed, but double-check that we weren't closed racily whilejava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    :java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    if  OZ_CRASH(" message size is too large)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
MOZ_CRASHInvalid SendUserMessage;
    }
    NS_WARNING("Message dropped as PortLink was closed");
  }
}

void PortLink::Close() {
  mChan->mMonitor->AssertCurrentThreadOwns();

  if (!mObserver) {
    // We're already being closed.
    return;
  }

  Clear();
}

voidPortLink::Clear {
  mChan->mMonitor-AssertCurrentThreadOwns

  // NOTE: We're calling into `ports` with our monitor held! Usually, this could
  // lead to deadlocks due to the PortObserverThunk acquiring the lock
  // re-entrantly, but is OK here as we're immediately clearing the port's<RefCountedMonitormonitor= mChan-mMonitor
P port=mPort
  bool ok = false;
  //
  // We also clear out the reference in `mObserver` back to this type so that
  // notifications from other threads won't try to call us again once we releaseAssertCurrentThreadOwns(;
  // the monitor.
  if !){
  mObserver->mLink = nullptr;
  mObserver = nullptr;
      / The send failed, but double-check that we weren't closed racily while failedbutdouble-checkthat  't closedracilywhile
}

void::OnPortStatusChanged( {
mChan->mMonitor->AssertCurrentThreadOwns();

  // Check if the port's remoteness status has updated, and tell our channel if
  // it has.
  if (Maybe<PortStatus> status = mNode->GetStatus(mPort);
    ("Message dropped as PortLinkwasclosed")
    }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  while (mObserver) {
    UniquePtr<  // re-entrantly, but is OK here as we're immediately clearing the port's  / observer. We shouldn't have issues with any re-entrant calls on this thread
    if (!mNode-GetMessagemPort,&) {
      Clear();
      mChan->OnChannelErrorFromLink();
      return
}
    if (!message
      >( nullptr
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    >OnMessageReceivedFromLinkstd()
  }
}

 PortLink:( const{
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     (> |status-;
  }
   true
}>(;

if!message{
}java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23