Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 231 insertions, 0 deletions

diff --git a/ipc/chromium/src/chrome/common/ipc_message.cc b/ipc/chromium/src/chrome/common/ipc_message.cc
new file mode 100644
index 0000000000..dc83f9acdf
--- /dev/null
+++ b/ipc/chromium/src/chrome/common/ipc_message.cc
@@ -0,0 +1,231 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+// Copyright (c) 2006-2008 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.
+
+#include "chrome/common/ipc_message.h"
+
+#include "base/logging.h"
+#include "build/build_config.h"
+
+#if defined(OS_POSIX)
+#  include "chrome/common/file_descriptor_set_posix.h"
+#endif
+#ifdef MOZ_TASK_TRACER
+#  include "GeckoTaskTracerImpl.h"
+#endif
+
+#include <utility>
+
+#include "nsISupportsImpl.h"
+
+#ifdef MOZ_TASK_TRACER
+using namespace mozilla::tasktracer;
+
+#  define MSG_HEADER_SZ                                    \
+    (IsStartLogging() && GetOrCreateTraceInfo() == nullptr \
+         ? sizeof(Header)                                  \
+         : sizeof(HeaderTaskTracer))
+#else
+#  define MSG_HEADER_SZ sizeof(Header)
+#endif
+
+namespace IPC {
+
+//------------------------------------------------------------------------------
+
+Message::~Message() { MOZ_COUNT_DTOR(IPC::Message); }
+
+Message::Message() : Pickle(MSG_HEADER_SZ) {
+  MOZ_COUNT_CTOR(IPC::Message);
+  header()->routing = header()->type = 0;
+#if defined(OS_POSIX)
+  header()->num_fds = 0;
+#endif
+#ifdef MOZ_TASK_TRACER
+  if (UseTaskTracerHeader()) {
+    header()->flags.SetTaskTracer();
+    HeaderTaskTracer* _header = static_cast<HeaderTaskTracer*>(header());
+    GetCurTraceInfo(&_header->source_event_id, &_header->parent_task_id,
+                    &_header->source_event_type);
+  }
+#endif
+}
+
+Message::Message(int32_t routing_id, msgid_t type, uint32_t segment_capacity,
+                 HeaderFlags flags, bool recordWriteLatency)
+    : Pickle(MSG_HEADER_SZ, segment_capacity) {
+  MOZ_COUNT_CTOR(IPC::Message);
+  header()->routing = routing_id;
+  header()->type = type;
+  header()->flags = flags;
+#if defined(OS_POSIX)
+  header()->num_fds = 0;
+#endif
+  header()->interrupt_remote_stack_depth_guess = static_cast<uint32_t>(-1);
+  header()->interrupt_local_stack_depth = static_cast<uint32_t>(-1);
+  header()->seqno = 0;
+#if defined(OS_MACOSX)
+  header()->cookie = 0;
+#endif
+#ifdef MOZ_TASK_TRACER
+  if (UseTaskTracerHeader()) {
+    header()->flags.SetTaskTracer();
+    HeaderTaskTracer* _header = static_cast<HeaderTaskTracer*>(header());
+    GetCurTraceInfo(&_header->source_event_id, &_header->parent_task_id,
+                    &_header->source_event_type);
+  }
+#endif
+  if (recordWriteLatency) {
+    create_time_ = mozilla::TimeStamp::Now();
+  }
+}
+
+#ifndef MOZ_TASK_TRACER
+#  define MSG_HEADER_SZ_DATA sizeof(Header)
+#else
+#  define MSG_HEADER_SZ_DATA                                     \
+    (reinterpret_cast<const Header*>(data)->flags.IsTaskTracer() \
+         ? sizeof(HeaderTaskTracer)                              \
+         : sizeof(Header))
+#endif
+
+Message::Message(const char* data, int data_len)
+    : Pickle(MSG_HEADER_SZ_DATA, data, data_len) {
+  MOZ_COUNT_CTOR(IPC::Message);
+}
+
+Message::Message(Message&& other) : Pickle(std::move(other)) {
+  MOZ_COUNT_CTOR(IPC::Message);
+#if defined(OS_POSIX)
+  file_descriptor_set_ = std::move(other.file_descriptor_set_);
+#endif
+}
+
+/*static*/ Message* Message::IPDLMessage(int32_t routing_id, msgid_t type,
+                                         HeaderFlags flags) {
+  return new Message(routing_id, type, 0, flags, true);
+}
+
+/*static*/ Message* Message::ForSyncDispatchError(NestedLevel level) {
+  auto* m = new Message(0, 0, 0, HeaderFlags(level));
+  auto& flags = m->header()->flags;
+  flags.SetSync();
+  flags.SetReply();
+  flags.SetReplyError();
+  return m;
+}
+
+/*static*/ Message* Message::ForInterruptDispatchError() {
+  auto* m = new Message();
+  auto& flags = m->header()->flags;
+  flags.SetInterrupt();
+  flags.SetReply();
+  flags.SetReplyError();
+  return m;
+}
+
+Message& Message::operator=(Message&& other) {
+  *static_cast<Pickle*>(this) = std::move(other);
+#if defined(OS_POSIX)
+  file_descriptor_set_.swap(other.file_descriptor_set_);
+#endif
+  return *this;
+}
+
+void Message::CopyFrom(const Message& other) {
+  Pickle::CopyFrom(other);
+#if defined(OS_POSIX)
+  MOZ_ASSERT(!file_descriptor_set_);
+  if (other.file_descriptor_set_) {
+    file_descriptor_set_ = new FileDescriptorSet;
+    file_descriptor_set_->CopyFrom(*other.file_descriptor_set_);
+  }
+#endif
+}
+
+#if defined(OS_POSIX)
+bool Message::WriteFileDescriptor(const base::FileDescriptor& descriptor) {
+  // We write the index of the descriptor so that we don't have to
+  // keep the current descriptor as extra decoding state when deserialising.
+  // Also, we rely on each file descriptor being accompanied by sizeof(int)
+  // bytes of data in the message. See the comment for input_cmsg_buf_.
+  WriteInt(file_descriptor_set()->size());
+  if (descriptor.auto_close) {
+    return file_descriptor_set()->AddAndAutoClose(descriptor.fd);
+  } else {
+    return file_descriptor_set()->Add(descriptor.fd);
+  }
+}
+
+bool Message::ReadFileDescriptor(PickleIterator* iter,
+                                 base::FileDescriptor* descriptor) const {
+  int descriptor_index;
+  if (!ReadInt(iter, &descriptor_index)) return false;
+
+  FileDescriptorSet* file_descriptor_set = file_descriptor_set_.get();
+  if (!file_descriptor_set) return false;
+
+  descriptor->fd = file_descriptor_set->GetDescriptorAt(descriptor_index);
+  descriptor->auto_close = false;
+
+  return descriptor->fd >= 0;
+}
+
+void Message::EnsureFileDescriptorSet() {
+  if (file_descriptor_set_.get() == NULL)
+    file_descriptor_set_ = new FileDescriptorSet;
+}
+
+uint32_t Message::num_fds() const {
+  return file_descriptor_set() ? file_descriptor_set()->size() : 0;
+}
+
+#endif
+
+void Message::AssertAsLargeAsHeader() const {
+  MOZ_DIAGNOSTIC_ASSERT(size() >= MSG_HEADER_SZ);
+  MOZ_DIAGNOSTIC_ASSERT(CurrentSize() >= MSG_HEADER_SZ);
+  // Our buffers should agree with what our header specifies.
+  MOZ_DIAGNOSTIC_ASSERT(size() == CurrentSize());
+}
+
+#ifdef MOZ_TASK_TRACER
+void* MessageTask() { return reinterpret_cast<void*>(&MessageTask); }
+
+void Message::TaskTracerDispatch() {
+  if (header()->flags.IsTaskTracer()) {
+    HeaderTaskTracer* _header = static_cast<HeaderTaskTracer*>(header());
+    _header->task_id = GenNewUniqueTaskId();
+    uintptr_t* vtab = reinterpret_cast<uintptr_t*>(&MessageTask);
+    LogVirtualTablePtr(_header->task_id, _header->source_event_id, vtab);
+    LogDispatch(_header->task_id, _header->parent_task_id,
+                _header->source_event_id, _header->source_event_type);
+  }
+}
+
+Message::AutoTaskTracerRun::AutoTaskTracerRun(Message& aMsg)
+    : mMsg(aMsg), mTaskId(0), mSourceEventId(0) {
+  if (mMsg.header()->flags.IsTaskTracer()) {
+    const HeaderTaskTracer* _header =
+        static_cast<HeaderTaskTracer*>(mMsg.header());
+    LogBegin(_header->task_id, _header->source_event_id);
+    SetCurTraceInfo(_header->source_event_id, _header->task_id,
+                    _header->source_event_type);
+    mTaskId = _header->task_id;
+    mSourceEventId = _header->source_event_id;
+  } else {
+    SetCurTraceInfo(0, 0, SourceEventType::Unknown);
+  }
+}
+
+Message::AutoTaskTracerRun::~AutoTaskTracerRun() {
+  if (mTaskId) {
+    AddLabel("IPC Message %s", mMsg.name());
+    LogEnd(mTaskId, mSourceEventId);
+  }
+}
+#endif
+
+}  // namespace IPC