registry speed ups (part of 12817)

2000-02-16 07:45:20 +00:00 · 2000-02-16 07:45:20 +00:00 · f620060761
--- a/js/src/xpconnect/loader/mozJSComponentLoader.cpp
+++ b/js/src/xpconnect/loader/mozJSComponentLoader.cpp
@ -40,7 +40,7 @@ const char jsComponentTypeName[] = "text/javascript";
 /* XXX export properly from libxpcom, for now this will let Mac build */
 const char fileSizeValueName[] = "FileSize";
 const char lastModValueName[] = "LastModTimeStamp";
-const char xpcomKeyName[] = "Software/Mozilla/XPCOM";
+const char xpcomKeyName[] = "software/mozilla/XPCOM/components";

 const char kJSRuntimeServiceProgID[] = "nsJSRuntimeService";
 const char kXPConnectServiceProgID[] = "nsIXPConnect";
@ -351,12 +351,8 @@ mozJSComponentLoader::SetRegistryInfo(const char *registryLocation,

    nsresult rv;
    nsRegistryKey key;
-    rv = mRegistry->GetSubtreeRaw(mXPCOMKey, registryLocation,
-                                  &key);
-
-    if (rv == NS_ERROR_REG_NOT_FOUND)
-        rv = mRegistry->AddSubtreeRaw(mXPCOMKey, registryLocation, &key);

+    rv = mRegistry->AddSubtreeRaw(mXPCOMKey, registryLocation, &key);
    if (NS_FAILED(rv))
        return rv;

--- a/modules/libreg/xpcom/nsRegistry.cpp
+++ b/modules/libreg/xpcom/nsRegistry.cpp
@ -853,13 +853,56 @@ NS_IMETHODIMP nsRegistry::AddSubtreeRaw( nsRegistryKey baseKey, const char *path
 | Deletes the subtree at a given location using NR_RegDeleteKey.               |
 ------------------------------------------------------------------------------*/
 NS_IMETHODIMP nsRegistry::RemoveSubtree( nsRegistryKey baseKey, const char *path ) {
+    nsresult rv = NS_OK;
    REGERR err = REGERR_OK;
-    // Delete the subkey.
+
+	// libreg doesn't delete keys if there are subkeys under the key
+	// Hence we have to recurse through to delete the subtree
+
+    RKEY key;
+
    PR_Lock(mregLock);
-    err = NR_RegDeleteKey( mReg,(RKEY)baseKey,(char*)path );
+    err = NR_RegGetKey(mReg, baseKey, (char *)path, &key);
    PR_Unlock(mregLock);
-    // Convert result.
-    return regerr2nsresult( err );
+    if (err != REGERR_OK)
+	{
+		rv = regerr2nsresult( err );
+        return rv;
+	}
+
+    // Now recurse through and delete all keys under hierarchy
+	
+    char subkeyname[MAXREGPATHLEN+1];
+    REGENUM state = 0;
+    subkeyname[0] = '\0';
+    while (NR_RegEnumSubkeys(mReg, key, &state, subkeyname, sizeof(subkeyname),
+           REGENUM_NORMAL) == REGERR_OK)
+    {
+#ifdef DEBUG_dp
+		printf("...recursing into %s\n", subkeyname);
+#endif /* DEBUG_dp */
+        // Even though this is not a "Raw" API the subkeys may still, in fact,
+        // *be* raw. Since we're recursively deleting this will work either way.
+        // If we were guaranteed none would be raw then a depth-first enumeration
+        // would be much more efficient.
+        err = RemoveSubtreeRaw(key, subkeyname);
+        if (err != REGERR_OK) break;
+    }
+
+    // If success in deleting all subkeys, delete this key too
+    if (err == REGERR_OK)
+    {
+#ifdef DEBUG_dp
+		printf("...deleting %s\n", path);
+#endif /* DEBUG_dp */
+        PR_Lock(mregLock);
+        err = NR_RegDeleteKey(mReg, baseKey, (char *)path);
+        PR_Unlock(mregLock);
+    }
+
+	// Convert result.
+  	rv = regerr2nsresult( err );
+    return rv;
 }


--- a/xpcom/components/nsCategoryManager.cpp
+++ b/xpcom/components/nsCategoryManager.cpp
@ -162,7 +162,7 @@ nsCategoryManager::nsCategoryManager()
 nsresult
 nsCategoryManager::initialize()
  {
-    const char* kCategoriesRegistryPath = "Software/Mozilla/XPCOM/Categories";
+    const char* kCategoriesRegistryPath = "software/mozilla/XPCOM/categories";
      // Alas, this is kind of buried down here, but you can't put constant strings in a class declaration... oh, well


--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@ -66,13 +66,12 @@ PRLogModuleInfo* nsComponentManagerLog = NULL;
 #define PRINT_CRITICAL_ERROR_TO_SCREEN

 // Common Key Names 
-const char xpcomBaseName[]="XPCOM";
-const char xpcomKeyName[] ="Software/Mozilla/XPCOM";
-const char mozillaKeyName[]="Software/Mozilla";
-const char classesKeyName[]="Classes";
+const char xpcomKeyName[]="software/mozilla/XPCOM";
+const char classesKeyName[]="classes";
 const char classIDKeyName[]="CLSID";
-const char classesClassIDKeyName[]="Classes/CLSID";
-const char componentLoadersKeyName[]="ComponentLoaders";
+const char componentsKeyName[]="components";
+const char componentLoadersKeyName[]="componentLoaders";
+const char xpcomComponentsKeyName[]="software/mozilla/XPCOM/components";

 // Common Value Names
 const char classIDValueName[]="CLSID";
@ -407,20 +406,24 @@ nsComponentManagerImpl::PlatformInit(void)
    if (NS_FAILED(rv)) return rv;

    // Check the version of registry. Nuke old versions.
-    PlatformVersionCheck();
+    nsRegistryKey xpcomRoot;
+    rv = PlatformVersionCheck(&xpcomRoot);
+    if (NS_FAILED(rv)) return rv;

    // Open common registry keys here to speed access
    // Do this after PlatformVersionCheck as it may re-create our keys
-    rv = mRegistry->AddSubtree(nsIRegistry::Common, xpcomKeyName, &mXPCOMKey);
-    		
+    rv = mRegistry->AddSubtree(xpcomRoot, componentsKeyName, &mXPCOMKey);
    if (NS_FAILED(rv)) return rv;

-    rv = mRegistry->AddSubtree(nsIRegistry::Common, classesKeyName, &mClassesKey);
+    rv = mRegistry->AddSubtree(xpcomRoot, classesKeyName, &mClassesKey);
    if (NS_FAILED(rv)) return rv;

-    rv = mRegistry->AddSubtree(nsIRegistry::Common, classIDKeyName, &mCLSIDKey);
+    rv = mRegistry->AddSubtree(xpcomRoot, classIDKeyName, &mCLSIDKey);
    if (NS_FAILED(rv)) return rv;
    
+    rv = mRegistry->AddSubtree(xpcomRoot, componentLoadersKeyName, &mLoadersKey);
+    if (NS_FAILED(rv)) return rv;
+
    nsCOMPtr<nsIProperties> directoryService;
    rv = nsDirectoryService::Create(nsnull, 
                                    NS_GET_IID(nsIProperties), 
@ -460,13 +463,11 @@ nsComponentManagerImpl::PlatformInit(void)
 * the software as defined by NS_XPCOM_COMPONENT_MANAGER_VERSION_STRING
 */
 nsresult
-nsComponentManagerImpl::PlatformVersionCheck()
+nsComponentManagerImpl::PlatformVersionCheck(nsRegistryKey *aXPCOMRootKey)
 {
-
    nsRegistryKey xpcomKey;
    nsresult rv;
    rv = mRegistry->AddSubtree(nsIRegistry::Common, xpcomKeyName, &xpcomKey);
-    		
    if (NS_FAILED(rv)) return rv;
    
    nsXPIDLCString buf;
@ -482,61 +483,40 @@ nsComponentManagerImpl::PlatformVersionCheck()
                "Nuking xpcom registry hierarchy.", (const char *)buf,
                NS_XPCOM_COMPONENT_MANAGER_VERSION_STRING));

-        // Delete the XPCOM and CLSID hierarchy
-        nsRegistryKey mozillaKey;
-        rv = mRegistry->GetSubtree(nsIRegistry::Common, mozillaKeyName,
-                                   &mozillaKey);
+        // Delete the XPCOM hierarchy
+        rv = mRegistry->RemoveSubtree(nsIRegistry::Common, xpcomKeyName);
        if(NS_FAILED(rv))
        {
            PR_LOG(nsComponentManagerLog, PR_LOG_ALWAYS,
-                   ("nsComponentManager: Failed To Get Subtree (%s)",
-                    mozillaKeyName));         
-        }
-        else
-        {
-            rv = mRegistry->RemoveSubtreeRaw(mozillaKey, xpcomBaseName);
-            if(NS_FAILED(rv))
-            {
-                PR_LOG(nsComponentManagerLog, PR_LOG_ALWAYS,
-                       ("nsComponentManager: Failed To Nuke Subtree (%s)",xpcomKeyName));
-                return rv;
-            }
+                   ("nsComponentManager: Failed To Nuke Subtree (%s)",xpcomKeyName));
+            return rv;
        }

-        rv = mRegistry->GetSubtree(nsIRegistry::Common,classesKeyName, &mozillaKey);
+        // The top-level Classes and CLSID trees are from an early alpha version,
+        // we can probably remove these two deletions after the second beta or so.
+        rv = mRegistry->RemoveSubtree(nsIRegistry::Common, classIDKeyName);
        if(NS_FAILED(rv))
        {
            PR_LOG(nsComponentManagerLog, PR_LOG_ALWAYS,
-                   ("nsComponentManager: Failed To Get Subtree (%s)",classesKeyName));
+                   ("nsComponentManager: Failed To Nuke Subtree (%s)",classIDKeyName));
+            // don't return this error!
        }
-        else
+
+        rv = mRegistry->RemoveSubtree(nsIRegistry::Common, classesKeyName);
+        if(NS_FAILED(rv))
        {
-            rv = mRegistry->RemoveSubtreeRaw(mozillaKey, classIDKeyName);
-            if(NS_FAILED(rv))
-            {
-                PR_LOG(nsComponentManagerLog, PR_LOG_ALWAYS,
-                       ("nsComponentManager: Failed To Nuke Subtree (%s/%s)",classesKeyName,classIDKeyName));
-                return rv;
-            }
+            PR_LOG(nsComponentManagerLog, PR_LOG_ALWAYS,
+                   ("nsComponentManager: Failed To Nuke Subtree (%s)",classesKeyName));
+            // don't return this error!
        }
-        
-        // Recreate XPCOM and CLSID keys		
+
+        // Recreate XPCOM key and version
        rv = mRegistry->AddSubtree(nsIRegistry::Common,xpcomKeyName, &xpcomKey);
        if(NS_FAILED(rv))
        {
            PR_LOG(nsComponentManagerLog, PR_LOG_ALWAYS,
                   ("nsComponentManager: Failed To Add Subtree (%s)",xpcomKeyName));
            return rv;
-
-        }
-
-        rv = mRegistry->AddSubtree(nsIRegistry::Common,classesClassIDKeyName, NULL);
-        if(NS_FAILED(rv))
-        {
-            PR_LOG(nsComponentManagerLog, PR_LOG_ALWAYS,
-                   ("nsComponentManager: Failed To Add Subtree (%s)",classesClassIDKeyName));
-            return rv;
-
        }

        rv = mRegistry->SetStringUTF8(xpcomKey,versionValueName, NS_XPCOM_COMPONENT_MANAGER_VERSION_STRING);
@ -547,16 +527,18 @@ nsComponentManagerImpl::PlatformVersionCheck()
            return rv;
        }
    }
-    else 
+    else
    {
        PR_LOG(nsComponentManagerLog, PR_LOG_ALWAYS,
               ("nsComponentManager: platformVersionCheck() passed."));
    }

-    rv = mRegistry->AddSubtree(xpcomKey, componentLoadersKeyName,
-                               &mLoadersKey);
-    if (NS_FAILED(rv))
-        return rv;
+
+    // return the XPCOM key (null check deferred so cleanup allways happens)
+    if (!aXPCOMRootKey)
+        return NS_ERROR_NULL_POINTER;
+    else
+        *aXPCOMRootKey = xpcomKey;

    return NS_OK;
 }
@ -574,7 +556,7 @@ nsComponentManagerImpl::PlatformSetFileInfo(nsRegistryKey key, PRUint32 lastModi
 *
 * Stores the dll name, last modified time, size and 0 for number of
 * components in dll in the registry at location
- *		ROOTKEY_COMMON/Software/Netscape/XPCOM/dllname
+ *		ROOTKEY_COMMON/Software/Mozilla/XPCOM/Components/dllname
 */
 nsresult
 nsComponentManagerImpl::PlatformMarkNoComponents(nsDll *dll)
--- a/xpcom/components/nsComponentManager.h
+++ b/xpcom/components/nsComponentManager.h
@ -97,7 +97,7 @@ protected:
    // The following functions are the only ones that operate on the persistent
    // registry
    nsresult PlatformInit(void);
-    nsresult PlatformVersionCheck();
+    nsresult PlatformVersionCheck(nsRegistryKey *aXPCOMRootKey);
    nsresult PlatformRegister(const char *cidString, const char *className, const char *progID, nsDll *dll);
    nsresult PlatformUnregister(const char *cidString, const char *aLibrary);
    nsresult PlatformFind(const nsCID &aCID, nsFactoryEntry* *result);
@ -169,8 +169,9 @@ protected:
 * alpha0.60 : xpcom 2.0 landing
 * alpha0.70 : using nsIFileSpec. PRTime -> PRUint32
 * alpha0.90 : using nsIComponentLoader, abs:/rel:/lib:, shaver-cleanup
+ * alpha0.91 : restructured registry keys
 */
-#define NS_XPCOM_COMPONENT_MANAGER_VERSION_STRING "alpha0.90"
+#define NS_XPCOM_COMPONENT_MANAGER_VERSION_STRING "alpha0.91"

 ////////////////////////////////////////////////////////////////////////////////
 /**
--- a/xpcom/components/nsComponentManagerUtils.h
+++ b/xpcom/components/nsComponentManagerUtils.h
@ -242,8 +242,8 @@ do_CreateInstance( const char* aProgID, nsISupports* aOuter, nsresult* error = 0
 	}

 /* keys for registry use */
-extern const char xpcomBaseName[];
 extern const char xpcomKeyName[];
+extern const char xpcomComponentsKeyName[];
 extern const char lastModValueName[];
 extern const char fileSizeValueName[];
 extern const char nativeComponentType[];
--- a/xpcom/components/nsNativeComponentLoader.cpp
+++ b/xpcom/components/nsNativeComponentLoader.cpp
@ -160,7 +160,7 @@ nsNativeComponentLoader::Init(nsIComponentManager *aCompMgr, nsISupports *aReg)
    if (!mCompMgr || !mRegistry)
        return NS_ERROR_INVALID_ARG;

-    rv = mRegistry->GetSubtree(nsIRegistry::Common, xpcomKeyName,
+    rv = mRegistry->GetSubtree(nsIRegistry::Common, xpcomComponentsKeyName,
                               &mXPCOMKey);
    if (NS_FAILED(rv))
        return rv;
--- a/xpcom/components/nsRegistry.cpp
+++ b/xpcom/components/nsRegistry.cpp
@ -853,13 +853,56 @@ NS_IMETHODIMP nsRegistry::AddSubtreeRaw( nsRegistryKey baseKey, const char *path
 | Deletes the subtree at a given location using NR_RegDeleteKey.               |
 ------------------------------------------------------------------------------*/
 NS_IMETHODIMP nsRegistry::RemoveSubtree( nsRegistryKey baseKey, const char *path ) {
+    nsresult rv = NS_OK;
    REGERR err = REGERR_OK;
-    // Delete the subkey.
+
+	// libreg doesn't delete keys if there are subkeys under the key
+	// Hence we have to recurse through to delete the subtree
+
+    RKEY key;
+
    PR_Lock(mregLock);
-    err = NR_RegDeleteKey( mReg,(RKEY)baseKey,(char*)path );
+    err = NR_RegGetKey(mReg, baseKey, (char *)path, &key);
    PR_Unlock(mregLock);
-    // Convert result.
-    return regerr2nsresult( err );
+    if (err != REGERR_OK)
+	{
+		rv = regerr2nsresult( err );
+        return rv;
+	}
+
+    // Now recurse through and delete all keys under hierarchy
+	
+    char subkeyname[MAXREGPATHLEN+1];
+    REGENUM state = 0;
+    subkeyname[0] = '\0';
+    while (NR_RegEnumSubkeys(mReg, key, &state, subkeyname, sizeof(subkeyname),
+           REGENUM_NORMAL) == REGERR_OK)
+    {
+#ifdef DEBUG_dp
+		printf("...recursing into %s\n", subkeyname);
+#endif /* DEBUG_dp */
+        // Even though this is not a "Raw" API the subkeys may still, in fact,
+        // *be* raw. Since we're recursively deleting this will work either way.
+        // If we were guaranteed none would be raw then a depth-first enumeration
+        // would be much more efficient.
+        err = RemoveSubtreeRaw(key, subkeyname);
+        if (err != REGERR_OK) break;
+    }
+
+    // If success in deleting all subkeys, delete this key too
+    if (err == REGERR_OK)
+    {
+#ifdef DEBUG_dp
+		printf("...deleting %s\n", path);
+#endif /* DEBUG_dp */
+        PR_Lock(mregLock);
+        err = NR_RegDeleteKey(mReg, baseKey, (char *)path);
+        PR_Unlock(mregLock);
+    }
+
+	// Convert result.
+  	rv = regerr2nsresult( err );
+    return rv;
 }


--- a/xpcom/glue/nsComponentManagerUtils.h
+++ b/xpcom/glue/nsComponentManagerUtils.h
@ -242,8 +242,8 @@ do_CreateInstance( const char* aProgID, nsISupports* aOuter, nsresult* error = 0
 	}

 /* keys for registry use */
-extern const char xpcomBaseName[];
 extern const char xpcomKeyName[];
+extern const char xpcomComponentsKeyName[];
 extern const char lastModValueName[];
 extern const char fileSizeValueName[];
 extern const char nativeComponentType[];