Pull class MimeInfoUpdater out of UpdateMimeInfoThread

* Pull out base class MimeEntryProcessor out of AppMetaMimeCreator.
* Pull class MimeInfoUpdater out of UpdateMimeInfoThread and derive it
  from MimeEntryProcessor.
* MimeInfoUpdater: Instead of BMimeType::GuessMimeType(), use
  Database::GuessMimeType() directly.

headers/build/private/storage/mime/MimeEntryProcessor.h

@@ -0,0 +1 @@
+#include <../../../private/storage/mime/MimeEntryProcessor.h>

headers/private/storage/mime/AppMetaMimeCreator.h

@@ -5,16 +5,11 @@
  * Authors:
  *		Ingo Weinhold <[email protected]>
  */
-#ifndef _MIME_APP_META_MIME_CREATOR_H
+#ifndef _MIME_MIME_ENTRY_PROCESSOR_H
-#define _MIME_APP_META_MIME_CREATOR_H
+#define _MIME_MIME_ENTRY_PROCESSOR_H
 
 
-#include <SupportDefs.h>
+#include <mime/MimeEntryProcessor.h>
-
-#include <MergedDirectory.h>
-
-
-struct entry_ref;
 
 
 namespace BPrivate {
@@ -22,35 +17,14 @@ namespace Storage {
 namespace Mime {
 
 
-class Database;
+class AppMetaMimeCreator : public MimeEntryProcessor {
-
-
-class AppMetaMimeCreator {
-public:
-			class DatabaseLocker;
-
 public:
 								AppMetaMimeCreator(Database* database,
 									DatabaseLocker* databaseLocker,
 						   			int32 force);
-								~AppMetaMimeCreator();
+	virtual						~AppMetaMimeCreator();
 
-			status_t			Do(const entry_ref& entry, bool* _entryIsDir);
+	virtual	status_t			Do(const entry_ref& entry, bool* _entryIsDir);
-
-private:
-			Database*			fDatabase;
-			DatabaseLocker*		fDatabaseLocker;
-			int32				fForce;
-
-};
-
-
-class AppMetaMimeCreator::DatabaseLocker {
-public:
-	virtual						~DatabaseLocker();
-
-	virtual	bool				Lock() = 0;
-	virtual	void				Unlock() = 0;
 };
 
 
@@ -59,4 +33,4 @@ public:
 } // namespace BPrivate
 
 
-#endif	// _MIME_APP_META_MIME_CREATOR_H
+#endif	// _MIME_MIME_ENTRY_PROCESSOR_H

headers/private/storage/mime/MimeEntryProcessor.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2013, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *		Ingo Weinhold <[email protected]>
+ */
+#ifndef _MIME_APP_META_MIME_CREATOR_H
+#define _MIME_APP_META_MIME_CREATOR_H
+
+
+#include <SupportDefs.h>
+
+
+struct entry_ref;
+
+
+namespace BPrivate {
+namespace Storage {
+namespace Mime {
+
+
+class Database;
+
+
+class MimeEntryProcessor {
+public:
+			class DatabaseLocker;
+
+public:
+								MimeEntryProcessor(Database* database,
+									DatabaseLocker* databaseLocker,
+						   			int32 force);
+	virtual						~MimeEntryProcessor();
+
+	virtual	status_t			Do(const entry_ref& entry, bool* _entryIsDir)
+									= 0;
+
+protected:
+			Database*			fDatabase;
+			DatabaseLocker*		fDatabaseLocker;
+			int32				fForce;
+
+};
+
+
+class MimeEntryProcessor::DatabaseLocker {
+public:
+	virtual						~DatabaseLocker();
+
+	virtual	bool				Lock() = 0;
+	virtual	void				Unlock() = 0;
+};
+
+
+} // namespace Mime
+} // namespace Storage
+} // namespace BPrivate
+
+
+#endif	// _MIME_APP_META_MIME_CREATOR_H

headers/private/storage/mime/MimeInfoUpdater.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2013, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *		Ingo Weinhold <[email protected]>
+ */
+#ifndef _MIME_MIME_INFO_UPDATER_H
+#define _MIME_MIME_INFO_UPDATER_H
+
+
+#include <mime/MimeEntryProcessor.h>
+
+
+namespace BPrivate {
+namespace Storage {
+namespace Mime {
+
+
+class MimeInfoUpdater : public MimeEntryProcessor {
+public:
+								MimeInfoUpdater(Database* database,
+									DatabaseLocker* databaseLocker,
+						   			int32 force);
+	virtual						~MimeInfoUpdater();
+
+	virtual	status_t			Do(const entry_ref& entry, bool* _entryIsDir);
+};
+
+
+} // namespace Mime
+} // namespace Storage
+} // namespace BPrivate
+
+
+#endif	// _MIME_MIME_INFO_UPDATER_H

src/build/libbe/storage/Jamfile

@@ -43,6 +43,7 @@ BuildPlatformMergeObjectPIC <libbe_build>storage_kit.o :
 	DatabaseLocation.cpp
 	database_support.cpp
 	InstalledTypes.cpp
+	MimeEntryProcessor.cpp
 	MimeSniffer.cpp
 	SnifferRules.cpp
 	Supertype.cpp

src/kits/storage/mime/AppMetaMimeCreator.cpp

@@ -32,15 +32,10 @@ namespace Storage {
 namespace Mime {
 
 
-// #pragma mark - AppMetaMimeCreator
-
-
 AppMetaMimeCreator::AppMetaMimeCreator(Database* database,
 	DatabaseLocker* databaseLocker, int32 force)
 	:
-	fDatabase(database),
+	MimeEntryProcessor(database, databaseLocker, force)
-	fDatabaseLocker(databaseLocker),
-	fForce(force)
 {
 }
 
@@ -203,14 +198,6 @@ AppMetaMimeCreator::Do(const entry_ref& entry, bool* _entryIsDir)
 }
 
 
-// #pragma mark - DatabaseLocker
-
-
-AppMetaMimeCreator::DatabaseLocker::~DatabaseLocker()
-{
-}
-
-
 } // namespace Mime
 } // namespace Storage
 } // namespace BPrivate

src/kits/storage/mime/Jamfile

@@ -17,6 +17,8 @@ StaticLibrary libstorage_kit_mime.a :
 	DatabaseLocation.cpp
 	database_support.cpp
 	InstalledTypes.cpp
+	MimeEntryProcessor.cpp
+	MimeInfoUpdater.cpp
 	MimeSniffer.cpp
 	SnifferRules.cpp
 	Supertype.cpp

src/kits/storage/mime/MimeEntryProcessor.cpp

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2013, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *		Ingo Weinhold <[email protected]>
+ */
+
+
+#include <mime/AppMetaMimeCreator.h>
+
+
+namespace BPrivate {
+namespace Storage {
+namespace Mime {
+
+
+// #pragma mark - DatabaseLocker
+
+
+MimeEntryProcessor::DatabaseLocker::~DatabaseLocker()
+{
+}
+
+
+// #pragma mark - MimeEntryProcessor
+
+
+MimeEntryProcessor::MimeEntryProcessor(Database* database,
+	DatabaseLocker* databaseLocker, int32 force)
+	:
+	fDatabase(database),
+	fDatabaseLocker(databaseLocker),
+	fForce(force)
+{
+}
+
+
+MimeEntryProcessor::~MimeEntryProcessor()
+{
+}
+
+
+} // namespace Mime
+} // namespace Storage
+} // namespace BPrivate

src/kits/storage/mime/MimeInfoUpdater.cpp

@@ -0,0 +1,259 @@
+/*
+ * Copyright 2002-2013, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *		Tyler Dauwalder
+ *		Jonas Sundström, [email protected]
+ *		Michael Lotz, [email protected]
+ *		Ingo Weinhold, [email protected]
+ */
+
+
+#include <mime/MimeInfoUpdater.h>
+
+#include <stdlib.h>
+
+#include <AppFileInfo.h>
+#include <Bitmap.h>
+#include <File.h>
+#include <fs_attr.h>
+#include <MimeType.h>
+#include <String.h>
+
+#include <AutoLocker.h>
+#include <mime/Database.h>
+#include <mime/database_support.h>
+
+
+static const char *kAppFlagsAttribute = "BEOS:APP_FLAGS";
+
+
+static status_t
+update_icon(BAppFileInfo &appFileInfoRead, BAppFileInfo &appFileInfoWrite,
+	const char *type, BBitmap &icon, icon_size iconSize)
+{
+	status_t err = appFileInfoRead.GetIconForType(type, &icon, iconSize);
+	if (err == B_OK)
+		err = appFileInfoWrite.SetIconForType(type, &icon, iconSize);
+	else if (err == B_ENTRY_NOT_FOUND)
+		err = appFileInfoWrite.SetIconForType(type, NULL, iconSize);
+	return err;
+}
+
+
+static status_t
+update_icon(BAppFileInfo &appFileInfoRead, BAppFileInfo &appFileInfoWrite,
+	const char *type)
+{
+	uint8* data = NULL;
+	size_t size = 0;
+
+	status_t err = appFileInfoRead.GetIconForType(type, &data, &size);
+	if (err == B_OK)
+		err = appFileInfoWrite.SetIconForType(type, data, size);
+	else if (err == B_ENTRY_NOT_FOUND)
+		err = appFileInfoWrite.SetIconForType(type, NULL, size);
+
+	free(data);
+
+	return err;
+}
+
+
+static bool
+is_shared_object_mime_type(const BString &type)
+{
+	return (type == B_APP_MIME_TYPE);
+}
+
+
+namespace BPrivate {
+namespace Storage {
+namespace Mime {
+
+
+MimeInfoUpdater::MimeInfoUpdater(Database* database,
+	DatabaseLocker* databaseLocker, int32 force)
+	:
+	MimeEntryProcessor(database, databaseLocker, force)
+{
+}
+
+
+MimeInfoUpdater::~MimeInfoUpdater()
+{
+}
+
+
+status_t
+MimeInfoUpdater::Do(const entry_ref& entry, bool* _entryIsDir)
+{
+	bool updateType = false;
+	bool updateAppInfo = false;
+	BNode node;
+
+	status_t err = node.SetTo(&entry);
+	if (!err && _entryIsDir)
+		*_entryIsDir = node.IsDirectory();
+	if (!err) {
+		// If not forced, only update if the entry has no file type attribute
+		attr_info info;
+		if (fForce == B_UPDATE_MIME_INFO_FORCE_UPDATE_ALL
+			|| node.GetAttrInfo(kFileTypeAttr, &info) == B_ENTRY_NOT_FOUND) {
+			updateType = true;
+		}
+		updateAppInfo = (updateType
+			|| fForce == B_UPDATE_MIME_INFO_FORCE_KEEP_TYPE);
+	}
+
+	// guess the MIME type
+	BString type;
+	if (!err && (updateType || updateAppInfo)) {
+		AutoLocker<DatabaseLocker> databaseLocker(fDatabaseLocker);
+		err = fDatabase->GuessMimeType(&entry, &type);
+	}
+
+	// update the MIME type
+	if (!err && updateType) {
+		ssize_t len = type.Length() + 1;
+		ssize_t bytes = node.WriteAttr(kFileTypeAttr, kFileTypeType, 0, type,
+			len);
+		if (bytes < B_OK)
+			err = bytes;
+		else
+			err = (bytes != len ? (status_t)B_FILE_ERROR : (status_t)B_OK);
+	}
+
+	// update the app file info attributes, if this is a shared object
+	BFile file;
+	BAppFileInfo appFileInfoRead;
+	BAppFileInfo appFileInfoWrite;
+	if (!err && updateAppInfo && node.IsFile()
+		&& is_shared_object_mime_type(type)
+		&& file.SetTo(&entry, B_READ_WRITE) == B_OK
+		&& appFileInfoRead.SetTo(&file) == B_OK
+		&& appFileInfoWrite.SetTo(&file) == B_OK) {
+
+		// we read from resources and write to attributes
+		appFileInfoRead.SetInfoLocation(B_USE_RESOURCES);
+		appFileInfoWrite.SetInfoLocation(B_USE_ATTRIBUTES);
+
+		// signature
+		char signature[B_MIME_TYPE_LENGTH];
+		err = appFileInfoRead.GetSignature(signature);
+		if (err == B_OK)
+			err = appFileInfoWrite.SetSignature(signature);
+		else if (err == B_ENTRY_NOT_FOUND)
+			err = appFileInfoWrite.SetSignature(NULL);
+		if (err != B_OK)
+			return err;
+
+		// catalog entry
+		char catalogEntry[B_MIME_TYPE_LENGTH * 3];
+		err = appFileInfoRead.GetCatalogEntry(catalogEntry);
+		if (err == B_OK)
+			err = appFileInfoWrite.SetCatalogEntry(catalogEntry);
+		else if (err == B_ENTRY_NOT_FOUND)
+			err = appFileInfoWrite.SetCatalogEntry(NULL);
+		if (err != B_OK)
+			return err;
+
+		// app flags
+		uint32 appFlags;
+		err = appFileInfoRead.GetAppFlags(&appFlags);
+		if (err == B_OK) {
+			err = appFileInfoWrite.SetAppFlags(appFlags);
+		} else if (err == B_ENTRY_NOT_FOUND) {
+			file.RemoveAttr(kAppFlagsAttribute);
+			err = B_OK;
+		}
+		if (err != B_OK)
+			return err;
+
+		// supported types
+		BMessage supportedTypes;
+		bool hasSupportedTypes = false;
+		err = appFileInfoRead.GetSupportedTypes(&supportedTypes);
+		if (err == B_OK) {
+			err = appFileInfoWrite.SetSupportedTypes(&supportedTypes);
+			hasSupportedTypes = true;
+		} else if (err == B_ENTRY_NOT_FOUND)
+			err = appFileInfoWrite.SetSupportedTypes(NULL);
+		if (err != B_OK)
+			return err;
+
+		// vector icon
+		err = update_icon(appFileInfoRead, appFileInfoWrite, NULL);
+		if (err != B_OK)
+			return err;
+
+		// small icon
+		BBitmap smallIcon(BRect(0, 0, 15, 15), B_BITMAP_NO_SERVER_LINK,
+			B_CMAP8);
+		if (smallIcon.InitCheck() != B_OK)
+			return smallIcon.InitCheck();
+		err = update_icon(appFileInfoRead, appFileInfoWrite, NULL, smallIcon,
+			B_MINI_ICON);
+		if (err != B_OK)
+			return err;
+
+		// large icon
+		BBitmap largeIcon(BRect(0, 0, 31, 31), B_BITMAP_NO_SERVER_LINK,
+			B_CMAP8);
+		if (largeIcon.InitCheck() != B_OK)
+			return largeIcon.InitCheck();
+		err = update_icon(appFileInfoRead, appFileInfoWrite, NULL, largeIcon,
+			B_LARGE_ICON);
+		if (err != B_OK)
+			return err;
+
+		// version infos
+		const version_kind versionKinds[]
+			= {B_APP_VERSION_KIND, B_SYSTEM_VERSION_KIND};
+		for (int i = 0; i < 2; i++) {
+			version_kind kind = versionKinds[i];
+			version_info versionInfo;
+			err = appFileInfoRead.GetVersionInfo(&versionInfo, kind);
+			if (err == B_OK)
+				err = appFileInfoWrite.SetVersionInfo(&versionInfo, kind);
+			else if (err == B_ENTRY_NOT_FOUND)
+				err = appFileInfoWrite.SetVersionInfo(NULL, kind);
+			if (err != B_OK)
+				return err;
+		}
+
+		// icons for supported types
+		if (hasSupportedTypes) {
+			const char *supportedType;
+			for (int32 i = 0;
+				 supportedTypes.FindString("types", i, &supportedType) == B_OK;
+				 i++) {
+				// vector icon
+				err = update_icon(appFileInfoRead, appFileInfoWrite,
+					supportedType);
+				if (err != B_OK)
+					return err;
+
+				// small icon
+				err = update_icon(appFileInfoRead, appFileInfoWrite,
+					supportedType, smallIcon, B_MINI_ICON);
+				if (err != B_OK)
+					return err;
+
+				// large icon
+				err = update_icon(appFileInfoRead, appFileInfoWrite,
+					supportedType, largeIcon, B_LARGE_ICON);
+				if (err != B_OK)
+					return err;
+			}
+		}
+	}
+
+	return err;
+}
+
+
+} // namespace Mime
+} // namespace Storage
+} // namespace BPrivate

src/servers/registrar/MIMEManager.cpp

@@ -55,7 +55,7 @@ init_mime_sniffer_add_on_manager()
 
 
 class MIMEManager::DatabaseLocker
-	: public BPrivate::Storage::Mime::AppMetaMimeCreator::DatabaseLocker {
+	: public BPrivate::Storage::Mime::MimeEntryProcessor::DatabaseLocker {
 public:
 	DatabaseLocker(MIMEManager* manager)
 		:
@@ -280,7 +280,7 @@ MIMEManager::MessageReceived(BMessage *message)
 						thread = new(nothrow) UpdateMimeInfoThread(synchronous
 								? "update_mime_info (s)"
 								: "update_mime_info (a)",
-							B_NORMAL_PRIORITY + 1, &fDatabase,
+							B_NORMAL_PRIORITY + 1, &fDatabase, fDatabaseLocker,
 							BMessenger(&fThreadManager), &root, recursive,
 							force, synchronous ? message : NULL);
 						break;

src/servers/registrar/mime/CreateAppMetaMimeThread.cpp

@@ -19,7 +19,7 @@ namespace Mime {
 
 CreateAppMetaMimeThread::CreateAppMetaMimeThread(const char* name,
 	int32 priority, Database* database,
-	AppMetaMimeCreator::DatabaseLocker* databaseLocker,
+	MimeEntryProcessor::DatabaseLocker* databaseLocker,
 	BMessenger managerMessenger, const entry_ref* root, bool recursive,
 	int32 force, BMessage* replyee)
 	:

src/servers/registrar/mime/CreateAppMetaMimeThread.h

@@ -25,7 +25,7 @@ class CreateAppMetaMimeThread : public MimeUpdateThread {
 public:
 								CreateAppMetaMimeThread(const char* name,
 									int32 priority, Database* database,
-									AppMetaMimeCreator::DatabaseLocker*
+									MimeEntryProcessor::DatabaseLocker*
 										databaseLocker,
 									BMessenger managerMessenger,
 									const entry_ref* root, bool recursive,

src/servers/registrar/mime/UpdateMimeInfoThread.cpp

@@ -1,258 +1,55 @@
-//----------------------------------------------------------------------
+/*
-//  This software is part of the OpenBeOS distribution and is covered 
+ * Copyright 2002-2013, Haiku, Inc. All Rights Reserved.
-//  by the OpenBeOS license.
+ * Distributed under the terms of the MIT License.
-//---------------------------------------------------------------------
+ *
+ * Authors:
+ *		Tyler Dauwalder
+ *		Jonas Sundström, [email protected]
+ *		Michael Lotz, [email protected]
+ *		Ingo Weinhold, [email protected]
+ */
 /*!
 	\file UpdateMimeInfoThread.h
 	UpdateMimeInfoThread implementation
 */
 
+
 #include "UpdateMimeInfoThread.h"
 
-#include <stdlib.h>
-#include <string.h>
-
-#include <AppFileInfo.h>
-#include <Bitmap.h>
-#include <fs_attr.h>
-#include <Message.h>
-#include <MimeType.h>
-#include <mime/database_support.h>
-#include <Node.h>
 
 namespace BPrivate {
 namespace Storage {
 namespace Mime {
 
-static const char *kAppFlagsAttribute			= "BEOS:APP_FLAGS";
 
-// update_icon
-static status_t
-update_icon(BAppFileInfo &appFileInfoRead, BAppFileInfo &appFileInfoWrite,
-	const char *type, BBitmap &icon, icon_size iconSize)
-{
-	status_t err = appFileInfoRead.GetIconForType(type, &icon, iconSize);
-	if (err == B_OK)
-		err = appFileInfoWrite.SetIconForType(type, &icon, iconSize);
-	else if (err == B_ENTRY_NOT_FOUND)
-		err = appFileInfoWrite.SetIconForType(type, NULL, iconSize);
-	return err;
-}
-
-// update_icon
-static status_t
-update_icon(BAppFileInfo &appFileInfoRead, BAppFileInfo &appFileInfoWrite,
-	const char *type)
-{
-	uint8* data = NULL;
-	size_t size = 0;
-
-	status_t err = appFileInfoRead.GetIconForType(type, &data, &size);
-	if (err == B_OK)
-		err = appFileInfoWrite.SetIconForType(type, data, size);
-	else if (err == B_ENTRY_NOT_FOUND)
-		err = appFileInfoWrite.SetIconForType(type, NULL, size);
-
-	free(data);
-
-	return err;
-}
-
-// is_shared_object_mime_type
-static bool
-is_shared_object_mime_type(BMimeType &type)
-{
-	return (type == B_APP_MIME_TYPE);
-}
-
-
-// constructor
 //! Creates a new UpdateMimeInfoThread object
-UpdateMimeInfoThread::UpdateMimeInfoThread(const char *name, int32 priority,
+UpdateMimeInfoThread::UpdateMimeInfoThread(const char* name, int32 priority,
-	Database *database, BMessenger managerMessenger, const entry_ref *root,
+	Database* database, MimeEntryProcessor::DatabaseLocker* databaseLocker,
-	bool recursive, int32 force, BMessage *replyee)
+	BMessenger managerMessenger, const entry_ref* root, bool recursive,
-	: MimeUpdateThread(name, priority, database, managerMessenger, root,
+	int32 force, BMessage* replyee)
-		recursive, force, replyee)
+	:
+	MimeUpdateThread(name, priority, database, managerMessenger, root,
+		recursive, force, replyee),
+	fUpdater(database, databaseLocker, force)
 {
 }
 
-// DoMimeUpdate
+
 /*! \brief Performs an update_mime_info() update on the given entry
 
 	If the entry has no \c BEOS:TYPE attribute, or if \c fForce is true, the
 	entry is sniffed and its \c BEOS:TYPE attribute is set accordingly.
 */
 status_t
-UpdateMimeInfoThread::DoMimeUpdate(const entry_ref *entry, bool *entryIsDir)
+UpdateMimeInfoThread::DoMimeUpdate(const entry_ref* entry, bool* _entryIsDir)
 {
-	status_t err = entry ? B_OK : B_BAD_VALUE;
+	if (entry == NULL)
-	bool updateType = false;
+		return B_BAD_VALUE;
-	bool updateAppInfo = false;
-	BNode node;
 
-	if (!err)
+	return fUpdater.Do(*entry, _entryIsDir);
-		err = node.SetTo(entry);
-	if (!err && entryIsDir)
-		*entryIsDir = node.IsDirectory();
-	if (!err) {
-		// If not forced, only update if the entry has no file type attribute
-		attr_info info;
-		if (fForce == B_UPDATE_MIME_INFO_FORCE_UPDATE_ALL
-			|| node.GetAttrInfo(kFileTypeAttr, &info) == B_ENTRY_NOT_FOUND) {
-			updateType = true;
-		}
-		updateAppInfo = (updateType
-			|| fForce == B_UPDATE_MIME_INFO_FORCE_KEEP_TYPE);
-	}
-
-	// guess the MIME type
-	BMimeType type;
-	if (!err && (updateType || updateAppInfo)) {
-		err = BMimeType::GuessMimeType(entry, &type);
-		if (!err)
-			err = type.InitCheck();
-	}
-
-	// update the MIME type
-	if (!err && updateType) {
-		const char *typeStr = type.Type();
-		ssize_t len = strlen(typeStr)+1;
-		ssize_t bytes = node.WriteAttr(kFileTypeAttr, kFileTypeType, 0, typeStr,
-			len);
-		if (bytes < B_OK)
-			err = bytes;
-		else
-			err = (bytes != len ? (status_t)B_FILE_ERROR : (status_t)B_OK);
-	}
-
-	// update the app file info attributes, if this is a shared object
-	BFile file;
-	BAppFileInfo appFileInfoRead;
-	BAppFileInfo appFileInfoWrite;
-	if (!err && updateAppInfo && node.IsFile()
-		&& is_shared_object_mime_type(type)
-		&& file.SetTo(entry, B_READ_WRITE) == B_OK
-		&& appFileInfoRead.SetTo(&file) == B_OK
-		&& appFileInfoWrite.SetTo(&file) == B_OK) {
-
-		// we read from resources and write to attributes
-		appFileInfoRead.SetInfoLocation(B_USE_RESOURCES);
-		appFileInfoWrite.SetInfoLocation(B_USE_ATTRIBUTES);
-	
-		// signature
-		char signature[B_MIME_TYPE_LENGTH];
-		err = appFileInfoRead.GetSignature(signature);
-		if (err == B_OK)
-			err = appFileInfoWrite.SetSignature(signature);
-		else if (err == B_ENTRY_NOT_FOUND)
-			err = appFileInfoWrite.SetSignature(NULL);
-		if (err != B_OK)
-			return err;
-
-		// catalog entry
-		char catalogEntry[B_MIME_TYPE_LENGTH * 3];
-		err = appFileInfoRead.GetCatalogEntry(catalogEntry);
-		if (err == B_OK)
-			err = appFileInfoWrite.SetCatalogEntry(catalogEntry);
-		else if (err == B_ENTRY_NOT_FOUND)
-			err = appFileInfoWrite.SetCatalogEntry(NULL);
-		if (err != B_OK)
-			return err;
-
-		// app flags
-		uint32 appFlags;
-		err = appFileInfoRead.GetAppFlags(&appFlags);
-		if (err == B_OK) {
-			err = appFileInfoWrite.SetAppFlags(appFlags);
-		} else if (err == B_ENTRY_NOT_FOUND) {
-			file.RemoveAttr(kAppFlagsAttribute);
-			err = B_OK;
-		}
-		if (err != B_OK)
-			return err;
-
-		// supported types
-		BMessage supportedTypes;
-		bool hasSupportedTypes = false;
-		err = appFileInfoRead.GetSupportedTypes(&supportedTypes);
-		if (err == B_OK) {
-			err = appFileInfoWrite.SetSupportedTypes(&supportedTypes);
-			hasSupportedTypes = true;
-		} else if (err == B_ENTRY_NOT_FOUND)
-			err = appFileInfoWrite.SetSupportedTypes(NULL);
-		if (err != B_OK)
-			return err;
-
-		// vector icon
-		err = update_icon(appFileInfoRead, appFileInfoWrite, NULL);
-		if (err != B_OK)
-			return err;
-
-		// small icon
-		BBitmap smallIcon(BRect(0, 0, 15, 15), B_BITMAP_NO_SERVER_LINK,
-			B_CMAP8);
-		if (smallIcon.InitCheck() != B_OK)
-			return smallIcon.InitCheck();
-		err = update_icon(appFileInfoRead, appFileInfoWrite, NULL, smallIcon,
-			B_MINI_ICON);
-		if (err != B_OK)
-			return err;
-
-		// large icon
-		BBitmap largeIcon(BRect(0, 0, 31, 31), B_BITMAP_NO_SERVER_LINK,
-			B_CMAP8);
-		if (largeIcon.InitCheck() != B_OK)
-			return largeIcon.InitCheck();
-		err = update_icon(appFileInfoRead, appFileInfoWrite, NULL, largeIcon,
-			B_LARGE_ICON);
-		if (err != B_OK)
-			return err;
-
-		// version infos
-		const version_kind versionKinds[]
-			= {B_APP_VERSION_KIND, B_SYSTEM_VERSION_KIND};
-		for (int i = 0; i < 2; i++) {
-			version_kind kind = versionKinds[i];
-			version_info versionInfo;
-			err = appFileInfoRead.GetVersionInfo(&versionInfo, kind);
-			if (err == B_OK)
-				err = appFileInfoWrite.SetVersionInfo(&versionInfo, kind);
-			else if (err == B_ENTRY_NOT_FOUND)
-				err = appFileInfoWrite.SetVersionInfo(NULL, kind);
-			if (err != B_OK)
-				return err;
-		}
-
-		// icons for supported types
-		if (hasSupportedTypes) {
-			const char *supportedType;
-			for (int32 i = 0;
-				 supportedTypes.FindString("types", i, &supportedType) == B_OK;
-				 i++) {
-				// vector icon
-				err = update_icon(appFileInfoRead, appFileInfoWrite,
-					supportedType);
-				if (err != B_OK)
-					return err;
-
-				// small icon
-				err = update_icon(appFileInfoRead, appFileInfoWrite,
-					supportedType, smallIcon, B_MINI_ICON);
-				if (err != B_OK)
-					return err;
-		
-				// large icon
-				err = update_icon(appFileInfoRead, appFileInfoWrite,
-					supportedType, largeIcon, B_LARGE_ICON);
-				if (err != B_OK)
-					return err;
-			}
-		}
-	}
-
-	return err;
 }
 
+
 }	// namespace Mime
 }	// namespace Storage
 }	// namespace BPrivate

src/servers/registrar/mime/UpdateMimeInfoThread.h

@@ -10,20 +10,35 @@
 #ifndef _MIME_UPDATE_MIME_INFO_THREAD_H
 #define _MIME_UPDATE_MIME_INFO_THREAD_H
 
+
+#include <mime/MimeInfoUpdater.h>
+
 #include "MimeUpdateThread.h"
 
+
 namespace BPrivate {
 namespace Storage {
 namespace Mime {
 
+
 class UpdateMimeInfoThread : public MimeUpdateThread {
 public:
-	UpdateMimeInfoThread(const char *name, int32 priority, Database *database,
+								UpdateMimeInfoThread(const char* name,
-		BMessenger managerMessenger, const entry_ref *root, bool recursive,
+									int32 priority, Database* database,
-		int32 force, BMessage *replyee);
+									MimeEntryProcessor::DatabaseLocker*
-	status_t DoMimeUpdate(const entry_ref *entry, bool *entryIsDir);
+										databaseLocker,
+									BMessenger managerMessenger,
+									const entry_ref* root, bool recursive,
+									int32 force, BMessage* replyee);
+
+	virtual	status_t			DoMimeUpdate(const entry_ref* entry,
+									bool* _entryIsDir);
+
+private:
+			MimeInfoUpdater		fUpdater;
 };
-	
+
+
 }	// namespace Mime
 }	// namespace Storage
 }	// namespace BPrivate