--- a/xpcom/reflect/xptinfo/xptiInterfaceInfo.cpp
+++ b/xpcom/reflect/xptinfo/xptiInterfaceInfo.cpp
@@ -11,43 +11,42 @@
 #include "mozilla/DebugOnly.h"
 #include "mozilla/XPTInterfaceInfoManager.h"
 #include "mozilla/PodOperations.h"
 #include "jsapi.h"
 
 using namespace mozilla;
 
 /* static */ xptiInterfaceEntry*
-xptiInterfaceEntry::Create(const char* aName,
-                           const nsID& aIID,
-                           const XPTInterfaceDescriptor* aDescriptor,
+xptiInterfaceEntry::Create(const XPTInterfaceDirectoryEntry* aEntry,
                            xptiTypelibGuts* aTypelib)
 {
     void* place = XPT_CALLOC8(gXPTIStructArena, sizeof(xptiInterfaceEntry));
     if (!place) {
         return nullptr;
     }
-    return new (place) xptiInterfaceEntry(aName, aIID, aDescriptor, aTypelib);
+    return new (place) xptiInterfaceEntry(aEntry, aTypelib);
 }
 
-xptiInterfaceEntry::xptiInterfaceEntry(const char* aName,
-                                       const nsID& aIID,
-                                       const XPTInterfaceDescriptor* aDescriptor,
+xptiInterfaceEntry::xptiInterfaceEntry(const XPTInterfaceDirectoryEntry* aEntry,
                                        xptiTypelibGuts* aTypelib)
-    : mIID(aIID)
-    , mDescriptor(aDescriptor)
+    : mIID(aEntry->mIID)
+    , mDescriptor(aEntry->mInterfaceDescriptor)
     , mTypelib(aTypelib)
     , mParent(nullptr)
     , mInfo(nullptr)
     , mMethodBaseIndex(0)
     , mConstantBaseIndex(0)
     , mFlags(0)
-    , mName(aName)
+    , mName(aEntry->mName)
 {
     SetResolvedState(PARTIALLY_RESOLVED);
+    SetScriptableFlag(mDescriptor->IsScriptable());
+    SetBuiltinClassFlag(mDescriptor->IsBuiltinClass());
+    SetMainProcessScriptableOnlyFlag(mDescriptor->IsMainProcessScriptableOnly());
 }
 
 bool
 xptiInterfaceEntry::Resolve()
 {
     MutexAutoLock lock(XPTInterfaceInfoManager::GetResolveLock());
     return ResolveLocked();
 }

--- a/xpcom/reflect/xptinfo/xptiInterfaceInfoManager.cpp
+++ b/xpcom/reflect/xptinfo/xptiInterfaceInfoManager.cpp
@@ -151,29 +151,20 @@ XPTInterfaceInfoManager::VerifyAndAddEnt
     xptiInterfaceEntry* entry = mWorkingSet.mIIDTable.Get(iface->mIID);
     if (entry) {
         // XXX validate this info to find possible inconsistencies
         return;
     }
 
     // Build a new xptiInterfaceEntry object and hook it up.
 
-    entry = xptiInterfaceEntry::Create(iface->mName,
-                                       iface->mIID,
-                                       iface->mInterfaceDescriptor,
-                                       typelib);
+    entry = xptiInterfaceEntry::Create(iface, typelib);
     if (!entry)
         return;
 
-    //XXX  We should SetHeader too as part of the validation, no?
-    entry->SetScriptableFlag(iface->mInterfaceDescriptor->IsScriptable());
-    entry->SetBuiltinClassFlag(iface->mInterfaceDescriptor->IsBuiltinClass());
-    entry->SetMainProcessScriptableOnlyFlag(
-      iface->mInterfaceDescriptor->IsMainProcessScriptableOnly());
-
     mWorkingSet.mIIDTable.Put(entry->IID(), entry);
     mWorkingSet.mNameTable.Put(entry->GetTheName(), entry);
 
     typelib->SetEntryAt(idx, entry);
 }
 
 // this is a private helper
 static nsresult

--- a/xpcom/reflect/xptinfo/xptiprivate.h
+++ b/xpcom/reflect/xptinfo/xptiprivate.h
@@ -146,19 +146,17 @@ private:
 
 // No virtual methods.
 // We always create in the struct arena and construct using "placement new".
 // No members need dtor calls.
 
 class xptiInterfaceEntry
 {
 public:
-    static xptiInterfaceEntry* Create(const char* aName,
-                                      const nsID& aIID,
-                                      const XPTInterfaceDescriptor* aDescriptor,
+    static xptiInterfaceEntry* Create(const XPTInterfaceDirectoryEntry* aEntry,
                                       xptiTypelibGuts* aTypelib);
 
     enum {
         PARTIALLY_RESOLVED    = 1,
         FULLY_RESOLVED        = 2,
         RESOLVE_FAILED        = 3
     };
 
@@ -244,19 +242,17 @@ public:
     nsresult IsIID(const nsIID * IID, bool *_retval);
     nsresult GetNameShared(const char **name);
     nsresult GetIIDShared(const nsIID * *iid);
     nsresult IsFunction(bool *_retval);
     nsresult HasAncestor(const nsIID * iid, bool *_retval);
     nsresult GetIIDForParamNoAlloc(uint16_t methodIndex, const nsXPTParamInfo * param, nsIID *iid);
 
 private:
-    xptiInterfaceEntry(const char* aName,
-                       const nsID& aIID,
-                       const XPTInterfaceDescriptor* aDescriptor,
+    xptiInterfaceEntry(const XPTInterfaceDirectoryEntry* aDescriptor,
                        xptiTypelibGuts* aTypelib);
     ~xptiInterfaceEntry();
 
     void SetResolvedState(int state)
         {mFlags.SetState(uint8_t(state));}
 
     bool Resolve();