MAINT-5356: Conversion of Notecards and Gesture to use new coroutine uploading.

Minor reorganization of Upload Info classes.

indra/newview/llfloaternamedesc.cpp

@@ -176,17 +176,6 @@ void LLFloaterNameDesc::onBtnOK( )
 
     upload_new_resource(uploadInfo, callback, nruserdata);
 
-#if 0
-	upload_new_resource(mFilenameAndPath, // file
-			    getChild<LLUICtrl>("name_form")->getValue().asString(), 
-			    getChild<LLUICtrl>("description_form")->getValue().asString(), 
-			    0, LLFolderType::FT_NONE, LLInventoryType::IT_NONE,
-			    LLFloaterPerms::getNextOwnerPerms("Uploads"),
-				LLFloaterPerms::getGroupPerms("Uploads"),
-				LLFloaterPerms::getEveryonePerms("Uploads"),
-			    display_name, callback, expected_upload_cost, nruserdata);
-#endif
-
 	closeFloater(false);
 }
 

indra/newview/llpreviewgesture.cpp

@@ -52,6 +52,8 @@
 #include "llviewerobjectlist.h"
 #include "llviewerregion.h"
 #include "llviewerstats.h"
+#include "llviewerassetupload.h"
+#include "llcoproceduremanager.h"
 
 std::string NONE_LABEL;
 std::string SHIFT_LABEL;
@@ -1015,6 +1017,27 @@ struct LLSaveInfo
 };
 
 
+void finishInventoryUpload(LLUUID itemId, LLUUID newAssetId)
+{
+    // If this gesture is active, then we need to update the in-memory
+    // active map with the new pointer.				
+    if (LLGestureMgr::instance().isGestureActive(itemId))
+    {
+        //*TODO: This is crashing for some reason.  Fix it.
+        // Active gesture edited from menu.
+        LLGestureMgr::instance().replaceGesture(itemId, newAssetId);
+        gInventory.notifyObservers();
+    }
+
+    //gesture will have a new asset_id
+    LLPreviewGesture* previewp = LLFloaterReg::findTypedInstance<LLPreviewGesture>("preview_gesture", LLSD(itemId));
+    if (previewp)
+    {
+        previewp->onUpdateSucceeded();
+    }
+}
+
+
 void LLPreviewGesture::saveIfNeeded()
 {
 	if (!gAssetStorage)
@@ -1028,6 +1051,131 @@ void LLPreviewGesture::saveIfNeeded()
 		return;
 	}
 
+#if 0
+    // Copy the UI into a gesture
+    LLMultiGesture* gesture = createGesture();
+
+    // Serialize the gesture
+    S32 maxSize = gesture->getMaxSerialSize();
+    char* buffer = new char[maxSize];
+
+    LLDataPackerAsciiBuffer dp(buffer, maxSize);
+
+    bool ok = gesture->serialize(dp);
+
+    if (dp.getCurrentSize() > 1000)
+    {
+        LLNotificationsUtil::add("GestureSaveFailedTooManySteps");
+
+        delete gesture;
+        gesture = NULL;
+        return;
+    }
+    else if (!ok)
+    {
+        LLNotificationsUtil::add("GestureSaveFailedTryAgain");
+        delete gesture;
+        gesture = NULL;
+        return;
+    }
+
+    LLAssetID assetId;
+    LLPreview::onCommit();
+    bool delayedUpload(false);
+
+    LLViewerInventoryItem* item = (LLViewerInventoryItem*) getItem();
+    if (item)
+    {
+        const LLViewerRegion* region = gAgent.getRegion();
+        if (!region)
+        {
+            LL_WARNS() << "Not connected to a region, cannot save notecard." << LL_ENDL;
+            return;
+        }
+        std::string agent_url = region->getCapability("UpdateGestureAgentInventory");
+        std::string task_url = region->getCapability("UpdateGestureTaskInventory");
+
+        if (!agent_url.empty() && !task_url.empty())
+        {
+            std::string url;
+            NewResourceUploadInfo::ptr_t uploadInfo;
+
+            if (mObjectUUID.isNull() && !agent_url.empty())
+            {
+                //need to disable the preview floater so item
+                //isn't re-saved before new asset arrives
+                //fake out refresh.
+                item->setComplete(false);
+                refresh();
+                item->setComplete(true);
+
+                uploadInfo = NewResourceUploadInfo::ptr_t(new LLBufferedAssetUploadInfo(mItemUUID, LLAssetType::AT_GESTURE, buffer,
+                    boost::bind(&finishInventoryUpload, _1, _2)));
+                url = agent_url;
+            }
+            else if (!mObjectUUID.isNull() && !task_url.empty())
+            {
+                uploadInfo = NewResourceUploadInfo::ptr_t(new LLBufferedAssetUploadInfo(mObjectUUID, mItemUUID, LLAssetType::AT_GESTURE, buffer, NULL));
+                url = task_url;
+            }
+
+            if (!url.empty() && uploadInfo)
+            {
+                delayedUpload = true;
+
+                LLCoprocedureManager::CoProcedure_t proc = boost::bind(&LLViewerAssetUpload::AssetInventoryUploadCoproc, _1, _2, _3, url, uploadInfo);
+
+                LLCoprocedureManager::getInstance()->enqueueCoprocedure("LLViewerAssetUpload::AssetInventoryUploadCoproc", proc);
+            }
+
+        }
+        else if (gAssetStorage)
+        {
+            // Every save gets a new UUID.  Yup.
+            LLTransactionID tid;
+            tid.generate();
+            assetId = tid.makeAssetID(gAgent.getSecureSessionID());
+
+            LLVFile file(gVFS, assetId, LLAssetType::AT_GESTURE, LLVFile::APPEND);
+
+            S32 size = dp.getCurrentSize();
+            file.setMaxSize(size);
+            file.write((U8*)buffer, size);
+
+            LLLineEditor* descEditor = getChild<LLLineEditor>("desc");
+            LLSaveInfo* info = new LLSaveInfo(mItemUUID, mObjectUUID, descEditor->getText(), tid);
+            gAssetStorage->storeAssetData(tid, LLAssetType::AT_GESTURE, onSaveComplete, info, FALSE);
+        }
+
+    }
+
+    // If this gesture is active, then we need to update the in-memory
+    // active map with the new pointer.
+    if (!delayedUpload && LLGestureMgr::instance().isGestureActive(mItemUUID))
+    {
+        // gesture manager now owns the pointer
+        LLGestureMgr::instance().replaceGesture(mItemUUID, gesture, assetId);
+
+        // replaceGesture may deactivate other gestures so let the
+        // inventory know.
+        gInventory.notifyObservers();
+    }
+    else
+    {
+        // we're done with this gesture
+        delete gesture;
+        gesture = NULL;
+    }
+
+    mDirty = false;
+    // refresh will be called when callback
+    // if triggered when delayedUpload
+    if(!delayedUpload)
+    {
+        refresh();
+    }
+
+#else
 	// Copy the UI into a gesture
 	LLMultiGesture* gesture = createGesture();
 
@@ -1138,6 +1286,7 @@ void LLPreviewGesture::saveIfNeeded()
 
 	delete [] buffer;
 	buffer = NULL;
+#endif
 }
 
 

indra/newview/llpreviewnotecard.cpp

@@ -56,6 +56,8 @@
 #include "llappviewer.h"		// app_abort_quit()
 #include "lllineeditor.h"
 #include "lluictrlfactory.h"
+#include "llcoproceduremanager.h"
+#include "llviewerassetupload.h"
 
 ///----------------------------------------------------------------------------
 /// Class LLPreviewNotecard
@@ -404,6 +406,35 @@ struct LLSaveNotecardInfo
 	}
 };
 
+void finishInventoryUpload(LLUUID itemId, LLUUID newAssetId, LLUUID newItemId)
+{
+    // Update the UI with the new asset.
+    LLPreviewNotecard* nc = LLFloaterReg::findTypedInstance<LLPreviewNotecard>("preview_notecard", LLSD(itemId));
+    if (nc)
+    {
+        // *HACK: we have to delete the asset in the VFS so
+        // that the viewer will redownload it. This is only
+        // really necessary if the asset had to be modified by
+        // the uploader, so this can be optimized away in some
+        // cases. A better design is to have a new uuid if the
+        // script actually changed the asset.
+        if (nc->hasEmbeddedInventory())
+        {
+            gVFS->removeFile(newAssetId, LLAssetType::AT_NOTECARD);
+        }
+        if (newItemId.isNull())
+        {
+            nc->setAssetId(newAssetId);
+            nc->refreshFromInventory();
+        }
+        else
+        {
+            nc->refreshFromInventory(newItemId);
+        }
+    }
+}
+
+
 bool LLPreviewNotecard::saveIfNeeded(LLInventoryItem* copyitem)
 {
 	LLViewerTextEditor* editor = getChild<LLViewerTextEditor>("Notecard Editor");
@@ -416,14 +447,6 @@ bool LLPreviewNotecard::saveIfNeeded(LLInventoryItem* copyitem)
 
 	if(!editor->isPristine())
 	{
-		// We need to update the asset information
-		LLTransactionID tid;
-		LLAssetID asset_id;
-		tid.generate();
-		asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
-
-		LLVFile file(gVFS, asset_id, LLAssetType::AT_NOTECARD, LLVFile::APPEND);
-
 		std::string buffer;
 		if (!editor->exportBuffer(buffer))
 		{
@@ -432,52 +455,66 @@ bool LLPreviewNotecard::saveIfNeeded(LLInventoryItem* copyitem)
 
 		editor->makePristine();
 
-		S32 size = buffer.length() + 1;
-		file.setMaxSize(size);
-		file.write((U8*)buffer.c_str(), size);
-
 		const LLInventoryItem* item = getItem();
 		// save it out to database
-		if (item)
-		{			
-			const LLViewerRegion* region = gAgent.getRegion();
-			if (!region)
-			{
-				LL_WARNS() << "Not connected to a region, cannot save notecard." << LL_ENDL;
-				return false;
-			}
-			std::string agent_url = region->getCapability("UpdateNotecardAgentInventory");
-			std::string task_url = region->getCapability("UpdateNotecardTaskInventory");
-
-			if (mObjectUUID.isNull() && !agent_url.empty())
-			{
-				// Saving into agent inventory
-				mAssetStatus = PREVIEW_ASSET_LOADING;
-				setEnabled(FALSE);
-				LLSD body;
-				body["item_id"] = mItemUUID;
-				LL_INFOS() << "Saving notecard " << mItemUUID
-					<< " into agent inventory via " << agent_url << LL_ENDL;
-				LLHTTPClient::post(agent_url, body,
-					new LLUpdateAgentInventoryResponder(body, asset_id, LLAssetType::AT_NOTECARD));
-			}
-			else if (!mObjectUUID.isNull() && !task_url.empty())
-			{
-				// Saving into task inventory
-				mAssetStatus = PREVIEW_ASSET_LOADING;
-				setEnabled(FALSE);
-				LLSD body;
-				body["task_id"] = mObjectUUID;
-				body["item_id"] = mItemUUID;
-				LL_INFOS() << "Saving notecard " << mItemUUID << " into task "
-					<< mObjectUUID << " via " << task_url << LL_ENDL;
-				LLHTTPClient::post(task_url, body,
-					new LLUpdateTaskInventoryResponder(body, asset_id, LLAssetType::AT_NOTECARD));
-			}
+        if (item)
+        {
+            const LLViewerRegion* region = gAgent.getRegion();
+            if (!region)
+            {
+                LL_WARNS() << "Not connected to a region, cannot save notecard." << LL_ENDL;
+                return false;
+            }
+            std::string agent_url = region->getCapability("UpdateNotecardAgentInventory");
+            std::string task_url = region->getCapability("UpdateNotecardTaskInventory");
+
+            if (!agent_url.empty() && !task_url.empty())
+            {
+                std::string url;
+                NewResourceUploadInfo::ptr_t uploadInfo;
+
+                if (mObjectUUID.isNull() && !agent_url.empty())
+                {
+                    uploadInfo = NewResourceUploadInfo::ptr_t(new LLBufferedAssetUploadInfo(mItemUUID, LLAssetType::AT_NOTECARD, buffer, 
+                        boost::bind(&finishInventoryUpload, _1, _2, _3)));
+                    url = agent_url;
+                }
+                else if (!mObjectUUID.isNull() && !task_url.empty())
+                {
+                    uploadInfo = NewResourceUploadInfo::ptr_t(new LLBufferedAssetUploadInfo(mObjectUUID, mItemUUID, LLAssetType::AT_NOTECARD, buffer, 
+                        boost::bind(&finishInventoryUpload, _1, _3, LLUUID::null)));
+                    url = task_url;
+                }
+
+                if (!url.empty() && uploadInfo)
+                {
+                    mAssetStatus = PREVIEW_ASSET_LOADING;
+                    setEnabled(false);
+
+                    LLCoprocedureManager::CoProcedure_t proc = boost::bind(&LLViewerAssetUpload::AssetInventoryUploadCoproc, _1, _2, _3, url, uploadInfo);
+
+                    LLCoprocedureManager::getInstance()->enqueueCoprocedure("LLViewerAssetUpload::AssetInventoryUploadCoproc", proc);
+                }
+
+            }
 			else if (gAssetStorage)
 			{
+                // We need to update the asset information
+                LLTransactionID tid;
+                LLAssetID asset_id;
+                tid.generate();
+                asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
+
+                LLVFile file(gVFS, asset_id, LLAssetType::AT_NOTECARD, LLVFile::APPEND);
+
+
 				LLSaveNotecardInfo* info = new LLSaveNotecardInfo(this, mItemUUID, mObjectUUID,
 																tid, copyitem);
+
+                S32 size = buffer.length() + 1;
+                file.setMaxSize(size);
+                file.write((U8*)buffer.c_str(), size);
+
 				gAssetStorage->storeAssetData(tid, LLAssetType::AT_NOTECARD,
 												&onSaveComplete,
 												(void*)info,

indra/newview/llviewerassetupload.cpp

@@ -46,6 +46,56 @@
 #include "llappviewer.h"
 #include "llviewerstats.h"
 #include "llvfile.h"
+#include "llgesturemgr.h"
+#include "llpreviewnotecard.h"
+#include "llpreviewgesture.h"
+
+void dialog_refresh_all();
+
+NewResourceUploadInfo::NewResourceUploadInfo(LLTransactionID transactId,
+        LLAssetType::EType assetType, std::string name, std::string description,
+        S32 compressionInfo, LLFolderType::EType destinationType,
+        LLInventoryType::EType inventoryType, U32 nextOWnerPerms,
+        U32 groupPerms, U32 everyonePerms, S32 expectedCost) :
+    mTransactionId(transactId),
+    mAssetType(assetType),
+    mName(name),
+    mDescription(description),
+    mCompressionInfo(compressionInfo),
+    mDestinationFolderType(destinationType),
+    mInventoryType(inventoryType),
+    mNextOwnerPerms(nextOWnerPerms),
+    mGroupPerms(groupPerms),
+    mEveryonePerms(everyonePerms),
+    mExpectedUploadCost(expectedCost),
+    mFolderId(LLUUID::null),
+    mItemId(LLUUID::null),
+    mAssetId(LLAssetID::null)
+{ }
+
+
+NewResourceUploadInfo::NewResourceUploadInfo(std::string name, 
+        std::string description, S32 compressionInfo, 
+        LLFolderType::EType destinationType, LLInventoryType::EType inventoryType, 
+        U32 nextOWnerPerms, U32 groupPerms, U32 everyonePerms, S32 expectedCost):
+    mName(name),
+    mDescription(description),
+    mCompressionInfo(compressionInfo),
+    mDestinationFolderType(destinationType),
+    mInventoryType(inventoryType),
+    mNextOwnerPerms(nextOWnerPerms),
+    mGroupPerms(groupPerms),
+    mEveryonePerms(everyonePerms),
+    mExpectedUploadCost(expectedCost),
+    mTransactionId(),
+    mAssetType(LLAssetType::AT_NONE),
+    mFolderId(LLUUID::null),
+    mItemId(LLUUID::null),
+    mAssetId(LLAssetID::null)
+{ 
+    mTransactionId.generate();
+}
+
 
 LLSD NewResourceUploadInfo::prepareUpload()
 {
@@ -251,16 +301,14 @@ NewFileResourceUploadInfo::NewFileResourceUploadInfo(
     nextOWnerPerms, groupPerms, everyonePerms, expectedCost),
     mFileName(fileName)
 {
-    LLTransactionID tid;
-    tid.generate();
-    setTransactionId(tid);
 }
 
 
 
 LLSD NewFileResourceUploadInfo::prepareUpload()
 {
-    generateNewAssetId();
+    if (getAssetId().isNull())
+        generateNewAssetId();
 
     LLSD result = exportTempFile();
     if (result.has("error"))
@@ -394,7 +442,103 @@ LLSD NewFileResourceUploadInfo::exportTempFile()
 }
 
 //=========================================================================
+LLBufferedAssetUploadInfo::LLBufferedAssetUploadInfo(LLUUID itemId, LLAssetType::EType assetType, std::string buffer, invnUploadFinish_f finish) :
+    NewResourceUploadInfo(std::string(), std::string(), 0, LLFolderType::FT_NONE, LLInventoryType::IT_NONE,
+        0, 0, 0, 0),
+    mTaskUpload(false),
+    mTaskId(LLUUID::null),
+    mContents(buffer),
+    mInvnFinishFn(finish),
+    mTaskFinishFn(NULL)
+{
+    setItemId(itemId);
+    setAssetType(assetType);
+    
+}
+
+LLBufferedAssetUploadInfo::LLBufferedAssetUploadInfo(LLUUID taskId, LLUUID itemId, LLAssetType::EType assetType, std::string buffer, taskUploadFinish_f finish) :
+    NewResourceUploadInfo(std::string(), std::string(), 0, LLFolderType::FT_NONE, LLInventoryType::IT_NONE,
+        0, 0, 0, 0),
+    mTaskUpload(true),
+    mTaskId(taskId),
+    mContents(buffer),
+    mInvnFinishFn(NULL),
+    mTaskFinishFn(finish)
+{
+    setItemId(itemId);
+    setAssetType(assetType);
+}
+
+
+LLSD LLBufferedAssetUploadInfo::prepareUpload()
+{
+    if (getAssetId().isNull())
+        generateNewAssetId();
+
+    LLVFile file(gVFS, getAssetId(), getAssetType(), LLVFile::APPEND);
+
+    S32 size = mContents.length() + 1;
+    file.setMaxSize(size);
+    file.write((U8*)mContents.c_str(), size);
+
+    return LLSD().with("success", LLSD::Boolean(true));
+}
+
+LLSD LLBufferedAssetUploadInfo::generatePostBody()
+{
+    LLSD body;
+
+    if (!getTaskId().isNull())
+    {
+        body["task_id"] = getTaskId();
+    }
+    body["item_id"] = getItemId();
+
+    return body;
+}
+
+LLUUID LLBufferedAssetUploadInfo::finishUpload(LLSD &result)
+{
+    LLUUID newAssetId = result["new_asset"].asUUID();
+    LLUUID itemId = getItemId();
+
+    if (mTaskUpload)
+    {
+        LLUUID taskId = getTaskId();
+
+        dialog_refresh_all();
+
+        if (mTaskFinishFn)
+        {
+            mTaskFinishFn(itemId, taskId, newAssetId, result);
+        }
+    }
+    else
+    {
+        LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getItem(itemId);
+        if(!item)
+        {
+            LL_WARNS() << "Inventory item for " << getDisplayName() << " is no longer in agent inventory." << LL_ENDL;
+            return newAssetId;
+        }
 
+        // Update viewer inventory item
+        LLPointer<LLViewerInventoryItem> newItem = new LLViewerInventoryItem(item);
+        newItem->setAssetUUID(newAssetId);
+
+        gInventory.updateItem(newItem);
+
+        LL_INFOS() << "Inventory item " << item->getName() << " saved into " << newAssetId.asString() << LL_ENDL;
+
+        if (mInvnFinishFn)
+        {
+            mInvnFinishFn(itemId, newAssetId, newItem->getUUID(), result);
+        }
+        gInventory.notifyObservers();
+    }
+
+    return newAssetId;
+}
 
 //=========================================================================
 /*static*/
@@ -414,9 +558,12 @@ void LLViewerAssetUpload::AssetInventoryUploadCoproc(LLCoros::self &self, LLCore
 
     //self.yield();
 
-    std::string uploadMessage = "Uploading...\n\n";
-    uploadMessage.append(uploadInfo->getDisplayName());
-    LLUploadDialog::modalUploadDialog(uploadMessage);
+    if (uploadInfo->showUploadDialog())
+    {
+        std::string uploadMessage = "Uploading...\n\n";
+        uploadMessage.append(uploadInfo->getDisplayName());
+        LLUploadDialog::modalUploadDialog(uploadMessage);
+    }
 
     LLSD body = uploadInfo->generatePostBody();
 
@@ -428,7 +575,8 @@ void LLViewerAssetUpload::AssetInventoryUploadCoproc(LLCoros::self &self, LLCore
     if ((!status) || (result.has("error")))
     {
         HandleUploadError(status, result, uploadInfo);
-        LLUploadDialog::modalUploadFinished();
+        if (uploadInfo->showUploadDialog())
+            LLUploadDialog::modalUploadFinished();
         return;
     }
 
@@ -441,7 +589,8 @@ void LLViewerAssetUpload::AssetInventoryUploadCoproc(LLCoros::self &self, LLCore
     if (!status)
     {
         HandleUploadError(status, result, uploadInfo);
-        LLUploadDialog::modalUploadFinished();
+        if (uploadInfo->showUploadDialog())
+            LLUploadDialog::modalUploadFinished();
         return;
     }
 
@@ -494,7 +643,8 @@ void LLViewerAssetUpload::AssetInventoryUploadCoproc(LLCoros::self &self, LLCore
     }
 
     // remove the "Uploading..." message
-    LLUploadDialog::modalUploadFinished();
+    if (uploadInfo->showUploadDialog())
+        LLUploadDialog::modalUploadFinished();
 
     // Let the Snapshot floater know we have finished uploading a snapshot to inventory.
     LLFloater* floater_snapshot = LLFloaterReg::findInstance("snapshot");

indra/newview/llviewerassetupload.h

@@ -41,32 +41,17 @@ class NewResourceUploadInfo
     typedef boost::shared_ptr<NewResourceUploadInfo> ptr_t;
 
     NewResourceUploadInfo(
-            LLTransactionID transactId,
-            LLAssetType::EType assetType,
-            std::string name,
-            std::string description,
-            S32 compressionInfo,
-            LLFolderType::EType destinationType,
-            LLInventoryType::EType inventoryType,
-            U32 nextOWnerPerms,
-            U32 groupPerms,
-            U32 everyonePerms,
-            S32 expectedCost) :
-        mTransactionId(transactId),
-        mAssetType(assetType),
-        mName(name),
-        mDescription(description),
-        mCompressionInfo(compressionInfo),
-        mDestinationFolderType(destinationType),
-        mInventoryType(inventoryType),
-        mNextOwnerPerms(nextOWnerPerms),
-        mGroupPerms(groupPerms),
-        mEveryonePerms(everyonePerms),
-        mExpectedUploadCost(expectedCost),
-        mFolderId(LLUUID::null),
-        mItemId(LLUUID::null),
-        mAssetId(LLAssetID::null)
-    { }
+        LLTransactionID transactId,
+        LLAssetType::EType assetType,
+        std::string name,
+        std::string description,
+        S32 compressionInfo,
+        LLFolderType::EType destinationType,
+        LLInventoryType::EType inventoryType,
+        U32 nextOWnerPerms,
+        U32 groupPerms,
+        U32 everyonePerms,
+        S32 expectedCost);
 
     virtual ~NewResourceUploadInfo()
     { }
@@ -90,6 +75,8 @@ class NewResourceUploadInfo
     U32                 getEveryonePerms() const { return mEveryonePerms; };
     S32                 getExpectedUploadCost() const { return mExpectedUploadCost; };
 
+    virtual bool        showUploadDialog() const { return true; }
+
     virtual std::string getDisplayName() const;
 
     LLUUID              getFolderId() const { return mFolderId; }
@@ -98,33 +85,19 @@ class NewResourceUploadInfo
 
 protected:
     NewResourceUploadInfo(
-            std::string name,
-            std::string description,
-            S32 compressionInfo,
-            LLFolderType::EType destinationType,
-            LLInventoryType::EType inventoryType,
-            U32 nextOWnerPerms,
-            U32 groupPerms,
-            U32 everyonePerms,
-            S32 expectedCost) :
-        mName(name),
-        mDescription(description),
-        mCompressionInfo(compressionInfo),
-        mDestinationFolderType(destinationType),
-        mInventoryType(inventoryType),
-        mNextOwnerPerms(nextOWnerPerms),
-        mGroupPerms(groupPerms),
-        mEveryonePerms(everyonePerms),
-        mExpectedUploadCost(expectedCost),
-        mTransactionId(),
-        mAssetType(LLAssetType::AT_NONE),
-        mFolderId(LLUUID::null),
-        mItemId(LLUUID::null),
-        mAssetId(LLAssetID::null)
-    { }
+        std::string name,
+        std::string description,
+        S32 compressionInfo,
+        LLFolderType::EType destinationType,
+        LLInventoryType::EType inventoryType,
+        U32 nextOWnerPerms,
+        U32 groupPerms,
+        U32 everyonePerms,
+        S32 expectedCost);
 
     void                setTransactionId(LLTransactionID tid) { mTransactionId = tid; }
     void                setAssetType(LLAssetType::EType assetType) { mAssetType = assetType; }
+    void                setItemId(LLUUID itemId) { mItemId = itemId; }
 
     LLAssetID           generateNewAssetId();
     void                incrementUploadStats() const;
@@ -176,26 +149,52 @@ class NewFileResourceUploadInfo : public NewResourceUploadInfo
 
 };
 
-#if 0
-class NotecardResourceUploadInfo : public NewResourceUploadInfo
+
+class LLBufferedAssetUploadInfo : public NewResourceUploadInfo
 {
 public:
-    NotecardResourceUploadInfo(
-        );
+    typedef boost::function<void(LLUUID itemId, LLUUID newAssetId, LLUUID newItemId, LLSD response)> invnUploadFinish_f;
+    typedef boost::function<void(LLUUID itemId, LLUUID taskId, LLUUID newAssetId, LLSD response)> taskUploadFinish_f;
+
+    LLBufferedAssetUploadInfo(LLUUID itemId, LLAssetType::EType assetType, std::string buffer, invnUploadFinish_f finish);
+    LLBufferedAssetUploadInfo(LLUUID taskId, LLUUID itemId, LLAssetType::EType assetType, std::string buffer, taskUploadFinish_f finish);
+
+    virtual LLSD        prepareUpload();
+    virtual LLSD        generatePostBody();
+    virtual LLUUID      finishUpload(LLSD &result);
 
+    LLUUID              getTaskId() const { return mTaskId; }
+    const std::string & getContents() const { return mContents; }
+
+    virtual bool        showUploadDialog() const { return false; }
 
 protected:
 
+
 private:
+    bool                mTaskUpload;
+    LLUUID              mTaskId;
+    std::string         mContents;
+    invnUploadFinish_f  mInvnFinishFn;
+    taskUploadFinish_f  mTaskFinishFn;
+};
+
+class LLScriptAssetUpload : public LLBufferedAssetUploadInfo
+{
+public:
+    LLScriptAssetUpload(LLUUID itemId, LLAssetType::EType assetType, std::string buffer, invnUploadFinish_f finish);
+    LLScriptAssetUpload(LLUUID taskId, LLUUID itemId, LLAssetType::EType assetType, std::string buffer, taskUploadFinish_f finish);
+
+    virtual LLSD        generatePostBody();
+
 };
-#endif
 
 class LLViewerAssetUpload
 {
 public:
 
-    static void AssetInventoryUploadCoproc(LLCoros::self &self, LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &httpAdapter, const LLUUID &id,
-        std::string url, NewResourceUploadInfo::ptr_t uploadInfo);
+    static void AssetInventoryUploadCoproc(LLCoros::self &self, LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &httpAdapter, 
+        const LLUUID &id, std::string url, NewResourceUploadInfo::ptr_t uploadInfo);
 
 private:
     static void HandleUploadError(LLCore::HttpStatus status, LLSD &result, NewResourceUploadInfo::ptr_t &uploadInfo);