Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

1 files changed, 357 insertions, 0 deletions

diff --git a/comm/mailnews/db/mork/morkHandle.cpp b/comm/mailnews/db/mork/morkHandle.cpp
new file mode 100644
index 0000000000..e838f8b997
--- /dev/null
+++ b/comm/mailnews/db/mork/morkHandle.cpp
@@ -0,0 +1,357 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-  */
+/* 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/. */
+
+#ifndef _MDB_
+#  include "mdb.h"
+#endif
+
+#ifndef _MORK_
+#  include "mork.h"
+#endif
+
+#ifndef _MORKENV_
+#  include "morkEnv.h"
+#endif
+
+#ifndef _MORKFACTORY_
+#  include "morkFactory.h"
+#endif
+
+#ifndef _MORKPOOL_
+#  include "morkPool.h"
+#endif
+
+#ifndef _MORKHANDLE_
+#  include "morkHandle.h"
+#endif
+
+// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
+
+// ````` ````` ````` ````` `````
+// { ===== begin morkNode interface =====
+
+/*public virtual*/ void morkHandle::CloseMorkNode(
+    morkEnv* ev)  // CloseHandle() only if open
+{
+  if (this->IsOpenNode()) {
+    this->MarkClosing();
+    this->CloseHandle(ev);
+    this->MarkShut();
+  }
+}
+
+/*public virtual*/
+morkHandle::~morkHandle()  // assert CloseHandle() executed earlier
+{
+  MORK_ASSERT(mHandle_Env == 0);
+  MORK_ASSERT(mHandle_Face == 0);
+  MORK_ASSERT(mHandle_Object == 0);
+  MORK_ASSERT(mHandle_Magic == 0);
+  MORK_ASSERT(mHandle_Tag == morkHandle_kTag);  // should still have correct tag
+}
+
+/*public non-poly*/
+morkHandle::morkHandle(
+    morkEnv* ev,             // note morkUsage is always morkUsage_kPool
+    morkHandleFace* ioFace,  // must not be nil, cookie for this handle
+    morkObject* ioObject,    // must not be nil, the object for this handle
+    mork_magic inMagic)      // magic sig to denote specific subclass
+    : morkNode(ev, morkUsage::kPool, (nsIMdbHeap*)0L),
+      mHandle_Tag(0),
+      mHandle_Env(ev),
+      mHandle_Face(ioFace),
+      mHandle_Object(0),
+      mHandle_Magic(0) {
+  if (ioFace && ioObject) {
+    if (ev->Good()) {
+      mHandle_Tag = morkHandle_kTag;
+      morkObject::SlotStrongObject(ioObject, ev, &mHandle_Object);
+      morkHandle::SlotWeakHandle(this, ev, &ioObject->mObject_Handle);
+      if (ev->Good()) {
+        mHandle_Magic = inMagic;
+        mNode_Derived = morkDerived_kHandle;
+      }
+    } else
+      ev->CantMakeWhenBadError();
+  } else
+    ev->NilPointerError();
+}
+
+/*public non-poly*/ void morkHandle::CloseHandle(
+    morkEnv* ev)  // called by CloseMorkNode();
+{
+  if (this->IsNode()) {
+    morkObject* obj = mHandle_Object;
+    mork_bool objDidRefSelf = (obj && obj->mObject_Handle == this);
+    if (objDidRefSelf) obj->mObject_Handle = 0;  // drop the reference
+
+    morkObject::SlotStrongObject((morkObject*)0, ev, &mHandle_Object);
+    mHandle_Magic = 0;
+    // note mHandle_Tag MUST stay morkHandle_kTag for morkNode::ZapOld()
+    this->MarkShut();
+
+    if (objDidRefSelf)
+      this->CutWeakRef(ev);  // do last, because it might self destroy
+  } else
+    this->NonNodeError(ev);
+}
+
+// } ===== end morkNode methods =====
+// ````` ````` ````` ````` `````
+
+void morkHandle::NilFactoryError(morkEnv* ev) const {
+  ev->NewError("nil mHandle_Factory");
+}
+
+void morkHandle::NilHandleObjectError(morkEnv* ev) const {
+  ev->NewError("nil mHandle_Object");
+}
+
+void morkHandle::NonNodeObjectError(morkEnv* ev) const {
+  ev->NewError("non-node mHandle_Object");
+}
+
+void morkHandle::NonOpenObjectError(morkEnv* ev) const {
+  ev->NewError("non-open mHandle_Object");
+}
+
+void morkHandle::NewBadMagicHandleError(morkEnv* ev, mork_magic inMagic) const {
+  MORK_USED_1(inMagic);
+  ev->NewError("wrong mHandle_Magic");
+}
+
+void morkHandle::NewDownHandleError(morkEnv* ev) const {
+  if (this->IsHandle()) {
+    if (this->GoodHandleTag()) {
+      if (this->IsOpenNode())
+        ev->NewError("unknown down morkHandle error");
+      else
+        this->NonOpenNodeError(ev);
+    } else
+      ev->NewError("wrong morkHandle tag");
+  } else
+    ev->NewError("non morkHandle");
+}
+
+morkObject* morkHandle::GetGoodHandleObject(morkEnv* ev, mork_bool inMutable,
+                                            mork_magic inMagicType,
+                                            mork_bool inClosedOkay) const {
+  morkObject* outObject = 0;
+  if (this->IsHandle() && this->GoodHandleTag() &&
+      (inClosedOkay || this->IsOpenNode())) {
+    if (!inMagicType || mHandle_Magic == inMagicType) {
+      morkObject* obj = this->mHandle_Object;
+      if (obj) {
+        if (obj->IsNode()) {
+          if (inClosedOkay || obj->IsOpenNode()) {
+            if (this->IsMutable() || !inMutable)
+              outObject = obj;
+            else
+              this->NonMutableNodeError(ev);
+          } else
+            this->NonOpenObjectError(ev);
+        } else
+          this->NonNodeObjectError(ev);
+      } else if (!inClosedOkay)
+        this->NilHandleObjectError(ev);
+    } else
+      this->NewBadMagicHandleError(ev, inMagicType);
+  } else
+    this->NewDownHandleError(ev);
+
+  MORK_ASSERT(outObject || inClosedOkay);
+  return outObject;
+}
+
+morkEnv* morkHandle::CanUseHandle(nsIMdbEnv* mev, mork_bool inMutable,
+                                  mork_bool inClosedOkay,
+                                  nsresult* outErr) const {
+  morkEnv* outEnv = 0;
+  morkEnv* ev = morkEnv::FromMdbEnv(mev);
+  if (ev) {
+    morkObject* obj = this->GetGoodHandleObject(ev, inMutable,
+                                                /*magic*/ 0, inClosedOkay);
+    if (obj) {
+      outEnv = ev;
+    }
+    *outErr = ev->AsErr();
+  }
+  MORK_ASSERT(outEnv || inClosedOkay);
+  return outEnv;
+}
+
+// { ===== begin nsIMdbObject methods =====
+
+// { ----- begin attribute methods -----
+/*virtual*/ nsresult morkHandle::Handle_IsFrozenMdbObject(
+    nsIMdbEnv* mev, mdb_bool* outIsReadonly) {
+  nsresult outErr = NS_OK;
+  mdb_bool readOnly = mdbBool_kTrue;
+
+  morkEnv* ev = CanUseHandle(mev, /*inMutable*/ morkBool_kFalse,
+                             /*inClosedOkay*/ morkBool_kTrue, &outErr);
+  if (ev) {
+    readOnly = mHandle_Object->IsFrozen();
+
+    outErr = ev->AsErr();
+  }
+  MORK_ASSERT(outIsReadonly);
+  if (outIsReadonly) *outIsReadonly = readOnly;
+
+  return outErr;
+}
+// same as nsIMdbPort::GetIsPortReadonly() when this object is inside a port.
+// } ----- end attribute methods -----
+
+// { ----- begin factory methods -----
+/*virtual*/ nsresult morkHandle::Handle_GetMdbFactory(
+    nsIMdbEnv* mev, nsIMdbFactory** acqFactory) {
+  nsresult outErr = NS_OK;
+  nsIMdbFactory* handle = 0;
+
+  morkEnv* ev = CanUseHandle(mev, /*inMutable*/ morkBool_kFalse,
+                             /*inClosedOkay*/ morkBool_kTrue, &outErr);
+  if (ev) {
+    morkFactory* factory = ev->mEnv_Factory;
+    if (factory) {
+      handle = factory;
+      NS_ADDREF(handle);
+    } else
+      this->NilFactoryError(ev);
+
+    outErr = ev->AsErr();
+  }
+
+  MORK_ASSERT(acqFactory);
+  if (acqFactory) *acqFactory = handle;
+
+  return outErr;
+}
+// } ----- end factory methods -----
+
+// { ----- begin ref counting for well-behaved cyclic graphs -----
+/*virtual*/ nsresult morkHandle::Handle_GetWeakRefCount(
+    nsIMdbEnv* mev,  // weak refs
+    mdb_count* outCount) {
+  nsresult outErr = NS_OK;
+  mdb_count count = 0;
+
+  morkEnv* ev = CanUseHandle(mev, /*inMutable*/ morkBool_kFalse,
+                             /*inClosedOkay*/ morkBool_kTrue, &outErr);
+  if (ev) {
+    count = this->WeakRefsOnly();
+
+    outErr = ev->AsErr();
+  }
+  MORK_ASSERT(outCount);
+  if (outCount) *outCount = count;
+
+  return outErr;
+}
+/*virtual*/ nsresult morkHandle::Handle_GetStrongRefCount(
+    nsIMdbEnv* mev,  // strong refs
+    mdb_count* outCount) {
+  nsresult outErr = NS_OK;
+  mdb_count count = 0;
+
+  morkEnv* ev = CanUseHandle(mev, /*inMutable*/ morkBool_kFalse,
+                             /*inClosedOkay*/ morkBool_kTrue, &outErr);
+  if (ev) {
+    count = this->StrongRefsOnly();
+
+    outErr = ev->AsErr();
+  }
+  MORK_ASSERT(outCount);
+  if (outCount) *outCount = count;
+
+  return outErr;
+}
+
+/*virtual*/ nsresult morkHandle::Handle_AddWeakRef(nsIMdbEnv* mev) {
+  nsresult outErr = NS_OK;
+
+  morkEnv* ev = CanUseHandle(mev, /*inMutable*/ morkBool_kFalse,
+                             /*inClosedOkay*/ morkBool_kTrue, &outErr);
+  if (ev) {
+    this->AddWeakRef(ev);
+    outErr = ev->AsErr();
+  }
+
+  return outErr;
+}
+/*virtual*/ nsresult morkHandle::Handle_AddStrongRef(nsIMdbEnv* mev) {
+  nsresult outErr = NS_OK;
+
+  morkEnv* ev = CanUseHandle(mev, /*inMutable*/ morkBool_kFalse,
+                             /*inClosedOkay*/ morkBool_kFalse, &outErr);
+  if (ev) {
+    this->AddStrongRef(ev);
+    outErr = ev->AsErr();
+  }
+
+  return outErr;
+}
+
+/*virtual*/ nsresult morkHandle::Handle_CutWeakRef(nsIMdbEnv* mev) {
+  nsresult outErr = NS_OK;
+
+  morkEnv* ev = CanUseHandle(mev, /*inMutable*/ morkBool_kFalse,
+                             /*inClosedOkay*/ morkBool_kTrue, &outErr);
+  if (ev) {
+    this->CutWeakRef(ev);
+    outErr = ev->AsErr();
+  }
+
+  return outErr;
+}
+/*virtual*/ nsresult morkHandle::Handle_CutStrongRef(nsIMdbEnv* mev) {
+  nsresult outErr = NS_OK;
+  morkEnv* ev = CanUseHandle(mev, /*inMutable*/ morkBool_kFalse,
+                             /*inClosedOkay*/ morkBool_kTrue, &outErr);
+  if (ev) {
+    this->CutStrongRef(ev);
+    outErr = ev->AsErr();
+  }
+  return outErr;
+}
+
+/*virtual*/ nsresult morkHandle::Handle_CloseMdbObject(nsIMdbEnv* mev)
+// called at strong refs zero
+{
+  // if only one ref, Handle_CutStrongRef will clean up better.
+  if (mNode_Uses == 1) return Handle_CutStrongRef(mev);
+
+  nsresult outErr = NS_OK;
+
+  if (this->IsNode() && this->IsOpenNode()) {
+    morkEnv* ev = CanUseHandle(mev, /*inMutable*/ morkBool_kFalse,
+                               /*inClosedOkay*/ morkBool_kTrue, &outErr);
+    if (ev) {
+      morkObject* object = mHandle_Object;
+      if (object && object->IsNode() && object->IsOpenNode())
+        object->CloseMorkNode(ev);
+
+      this->CloseMorkNode(ev);
+      outErr = ev->AsErr();
+    }
+  }
+  return outErr;
+}
+
+/*virtual*/ nsresult morkHandle::Handle_IsOpenMdbObject(nsIMdbEnv* mev,
+                                                        mdb_bool* outOpen) {
+  MORK_USED_1(mev);
+  nsresult outErr = NS_OK;
+
+  MORK_ASSERT(outOpen);
+  if (outOpen) *outOpen = this->IsOpenNode();
+
+  return outErr;
+}
+// } ----- end ref counting -----
+
+// } ===== end nsIMdbObject methods =====
+
+// 456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789