Merge

1 files changed, 101 insertions, 628 deletions

diff --git a/indra/newview/lllogininstance.cpp b/indra/newview/lllogininstance.cpp
index 77eadef716..8d361d3161 100644
--- a/indra/newview/lllogininstance.cpp
+++ b/indra/newview/lllogininstance.cpp
@@ -31,6 +31,7 @@
 // llcommon
 #include "llevents.h"
 #include "stringize.h"
+#include "llsdserialize.h"
 
 // llmessage (!)
 #include "llfiltersd2xmlrpc.h" // for xml_escape_string()
@@ -47,16 +48,13 @@
 #include "llstartup.h"
 #include "llfloaterreg.h"
 #include "llnotifications.h"
+#include "llnotificationsutil.h"
 #include "llwindow.h"
 #include "llviewerwindow.h"
 #include "llprogressview.h"
-#if LL_LINUX || LL_SOLARIS
-#include "lltrans.h"
-#endif
 #include "llsecapi.h"
 #include "llstartup.h"
 #include "llmachineid.h"
-#include "llupdaterservice.h"
 #include "llevents.h"
 #include "llappviewer.h"
 #include "llsdserialize.h"
@@ -66,416 +64,16 @@
 
 const S32 LOGIN_MAX_RETRIES = 3;
 
-// this can be removed once it is defined by the build for all forks
-#ifndef ADDRESS_SIZE
-#  define ADDRESS_SIZE 32
-#endif
-
 class LLLoginInstance::Disposable {
 public:
 	virtual ~Disposable() {}
 };
 
-namespace {
-	class MandatoryUpdateMachine:
-		public LLLoginInstance::Disposable
-	{
-	public:
-		MandatoryUpdateMachine(LLLoginInstance & loginInstance, LLUpdaterService & updaterService);
-
-		void start(void);
-
-		LLNotificationsInterface& getNotificationsInterface() const
-		{
-			return mLoginInstance.getNotificationsInterface();
-		}
-
-	private:
-		class State;
-		class CheckingForUpdate;
-		class Error;
-		class ReadyToInstall; 
-		class StartingUpdaterService;
-		class WaitingForDownload;
-
-		boost::scoped_ptr<State> mState;
-		LLLoginInstance &  mLoginInstance;
-		LLUpdaterService & mUpdaterService;
-		
-		void setCurrentState(State * newState);
-	};
-
-	
-	class MandatoryUpdateMachine::State {
-	public:
-		virtual ~State() {}
-		virtual void enter(void) {}
-		virtual void exit(void) {}
-	};
-	
-	
-	class MandatoryUpdateMachine::CheckingForUpdate:
-	public MandatoryUpdateMachine::State
-	{
-	public:
-		CheckingForUpdate(MandatoryUpdateMachine & machine);
-		
-		virtual void enter(void);
-		virtual void exit(void);
-		
-	private:
-		LLTempBoundListener mConnection;
-		MandatoryUpdateMachine & mMachine;
-		LLProgressView * mProgressView;
-		
-		bool onEvent(LLSD const & event);
-	};
-	
-	
-	class MandatoryUpdateMachine::Error:
-	public MandatoryUpdateMachine::State
-	{
-	public:
-		Error(MandatoryUpdateMachine & machine);
-		
-		virtual void enter(void);
-		virtual void exit(void);
-		void onButtonClicked(const LLSD &, const LLSD &);
-		
-	private:
-		MandatoryUpdateMachine & mMachine;
-	};
-	
-	
-	class MandatoryUpdateMachine::ReadyToInstall:
-	public MandatoryUpdateMachine::State
-	{
-	public:
-		ReadyToInstall(MandatoryUpdateMachine & machine);
-		
-		virtual void enter(void);
-		virtual void exit(void);
-		
-	private:
-		//MandatoryUpdateMachine & mMachine;
-	};
-	
-	
-	class MandatoryUpdateMachine::StartingUpdaterService:
-	public MandatoryUpdateMachine::State
-	{
-	public:
-		StartingUpdaterService(MandatoryUpdateMachine & machine);
-		
-		virtual void enter(void);
-		virtual void exit(void);
-		void onButtonClicked(const LLSD & uiform, const LLSD & result);
-	private:
-		MandatoryUpdateMachine & mMachine;
-	};
-	
-	
-	class MandatoryUpdateMachine::WaitingForDownload:
-		public MandatoryUpdateMachine::State
-	{
-	public:
-		WaitingForDownload(MandatoryUpdateMachine & machine);
-		
-		virtual void enter(void);
-		virtual void exit(void);
-		
-	private:
-		LLTempBoundListener mConnection;
-		MandatoryUpdateMachine & mMachine;
-		LLProgressView * mProgressView;
-		
-		bool onEvent(LLSD const & event);
-	};
-}
-
 static const char * const TOS_REPLY_PUMP = "lllogininstance_tos_callback";
 static const char * const TOS_LISTENER_NAME = "lllogininstance_tos";
 
 std::string construct_start_string();
 
-
-
-// MandatoryUpdateMachine
-//-----------------------------------------------------------------------------
-
-
-MandatoryUpdateMachine::MandatoryUpdateMachine(LLLoginInstance & loginInstance, LLUpdaterService & updaterService):
-	mLoginInstance(loginInstance),
-	mUpdaterService(updaterService)
-{
-	; // No op.
-}
-
-
-void MandatoryUpdateMachine::start(void)
-{
-	LL_INFOS() << "starting mandatory update machine" << LL_ENDL;
-	
-	if(mUpdaterService.isChecking()) {
-		switch(mUpdaterService.getState()) {
-			case LLUpdaterService::UP_TO_DATE:
-				mUpdaterService.stopChecking();
-				mUpdaterService.startChecking();
-				// Fall through.
-			case LLUpdaterService::INITIAL:
-			case LLUpdaterService::CHECKING_FOR_UPDATE:
-				setCurrentState(new CheckingForUpdate(*this));
-				break;
-			case LLUpdaterService::TEMPORARY_ERROR:
-				setCurrentState(new Error(*this));
-				break;
-			case LLUpdaterService::DOWNLOADING:
-				setCurrentState(new WaitingForDownload(*this));
-				break;
-			case LLUpdaterService::TERMINAL:
-				if(LLUpdaterService::updateReadyToInstall()) {
-					setCurrentState(new ReadyToInstall(*this));
-				} else {
-					setCurrentState(new Error(*this));
-				}
-				break;
-			case LLUpdaterService::FAILURE:
-				setCurrentState(new Error(*this));
-				break;
-			default:
-				llassert(!"unpossible case");
-				break;
-		}
-	} else {
-		setCurrentState(new StartingUpdaterService(*this));
-	}
-}
-
-
-void MandatoryUpdateMachine::setCurrentState(State * newStatePointer)
-{
-	{
-		boost::scoped_ptr<State> newState(newStatePointer);
-		if(mState != 0) mState->exit();
-		mState.swap(newState);
-		
-		// Old state will be deleted on exit from this block before the new state
-		// is entered.
-	}
-	if(mState != 0) mState->enter();
-}
-
-
-
-// MandatoryUpdateMachine::CheckingForUpdate
-//-----------------------------------------------------------------------------
-
-
-MandatoryUpdateMachine::CheckingForUpdate::CheckingForUpdate(MandatoryUpdateMachine & machine):
-	mMachine(machine)
-{
-	; // No op.
-}
-
-
-void MandatoryUpdateMachine::CheckingForUpdate::enter(void)
-{
-	LL_INFOS() << "entering checking for update" << LL_ENDL;
-	
-	mProgressView = gViewerWindow->getProgressView();
-	mProgressView->setMessage("Looking for update...");
-	mProgressView->setText("There is a required update for your Second Life installation.");
-	mProgressView->setPercent(0);
-	mProgressView->setVisible(true);
-	mConnection = LLEventPumps::instance().obtain(LLUpdaterService::pumpName()).
-		listen("MandatoryUpdateMachine::CheckingForUpdate", boost::bind(&MandatoryUpdateMachine::CheckingForUpdate::onEvent, this, _1));
-}
-
-
-void MandatoryUpdateMachine::CheckingForUpdate::exit(void)
-{
-}
-
-
-bool MandatoryUpdateMachine::CheckingForUpdate::onEvent(LLSD const & event)
-{
-	if(event["type"].asInteger() == LLUpdaterService::STATE_CHANGE) {
-		switch(event["state"].asInteger()) {
-			case LLUpdaterService::DOWNLOADING:
-				mMachine.setCurrentState(new WaitingForDownload(mMachine));
-				break;
-			case LLUpdaterService::TEMPORARY_ERROR:
-			case LLUpdaterService::UP_TO_DATE:
-			case LLUpdaterService::TERMINAL:
-			case LLUpdaterService::FAILURE:
-				mProgressView->setVisible(false);
-				mMachine.setCurrentState(new Error(mMachine));
-				break;
-			case LLUpdaterService::INSTALLING:
-				llassert(!"can't possibly be installing");
-				break;
-			default:
-				break;
-		}
-	} else {
-		; // Ignore.
-	}
-	
-	return false;
-}
-
-
-
-// MandatoryUpdateMachine::Error
-//-----------------------------------------------------------------------------
-
-
-MandatoryUpdateMachine::Error::Error(MandatoryUpdateMachine & machine):
-	mMachine(machine)
-{
-	; // No op.
-}
-
-
-void MandatoryUpdateMachine::Error::enter(void)
-{
-	LL_INFOS() << "entering error" << LL_ENDL;
-	mMachine.getNotificationsInterface().add("FailedRequiredUpdateInstall", LLSD(), LLSD(), boost::bind(&MandatoryUpdateMachine::Error::onButtonClicked, this, _1, _2));
-}
-
-
-void MandatoryUpdateMachine::Error::exit(void)
-{
-	LLAppViewer::instance()->forceQuit();
-}
-
-
-void MandatoryUpdateMachine::Error::onButtonClicked(const LLSD &, const LLSD &)
-{
-	mMachine.setCurrentState(0);
-}
-
-
-
-// MandatoryUpdateMachine::ReadyToInstall
-//-----------------------------------------------------------------------------
-
-
-MandatoryUpdateMachine::ReadyToInstall::ReadyToInstall(MandatoryUpdateMachine & machine) //:
-	//mMachine(machine)
-{
-	; // No op.
-}
-
-
-void MandatoryUpdateMachine::ReadyToInstall::enter(void)
-{
-	LL_INFOS() << "entering ready to install" << LL_ENDL;
-	// Open update ready dialog.
-}
-
-
-void MandatoryUpdateMachine::ReadyToInstall::exit(void)
-{
-	// Restart viewer.
-}
-
-
-
-// MandatoryUpdateMachine::StartingUpdaterService
-//-----------------------------------------------------------------------------
-
-
-MandatoryUpdateMachine::StartingUpdaterService::StartingUpdaterService(MandatoryUpdateMachine & machine):
-	mMachine(machine)
-{
-	; // No op.
-}
-
-
-void MandatoryUpdateMachine::StartingUpdaterService::enter(void)
-{
-	LL_INFOS() << "entering start update service" << LL_ENDL;
-	mMachine.getNotificationsInterface().add("UpdaterServiceNotRunning", LLSD(), LLSD(), boost::bind(&MandatoryUpdateMachine::StartingUpdaterService::onButtonClicked, this, _1, _2));
-}
-
-
-void MandatoryUpdateMachine::StartingUpdaterService::exit(void)
-{
-	; // No op.
-}
-
-
-void MandatoryUpdateMachine::StartingUpdaterService::onButtonClicked(const LLSD & uiform, const LLSD & result)
-{
-	if(result["OK_okcancelbuttons"].asBoolean()) {
-		mMachine.mUpdaterService.startChecking(false);
-		mMachine.setCurrentState(new CheckingForUpdate(mMachine));
-	} else {
-		LLAppViewer::instance()->forceQuit();
-	}
-}
-
-
-
-// MandatoryUpdateMachine::WaitingForDownload
-//-----------------------------------------------------------------------------
-
-
-MandatoryUpdateMachine::WaitingForDownload::WaitingForDownload(MandatoryUpdateMachine & machine):
-	mMachine(machine),
-	mProgressView(0)
-{
-	; // No op.
-}
-
-
-void MandatoryUpdateMachine::WaitingForDownload::enter(void)
-{
-	LL_INFOS() << "entering waiting for download" << LL_ENDL;
-	mProgressView = gViewerWindow->getProgressView();
-	mProgressView->setMessage("Downloading update...");
-	std::ostringstream stream;
-	stream << "There is a required update for your Second Life installation." << std::endl <<
-		"Version " << mMachine.mUpdaterService.updatedVersion();
-	mProgressView->setText(stream.str());
-	mProgressView->setPercent(0);
-	mProgressView->setVisible(true);
-	mConnection = LLEventPumps::instance().obtain(LLUpdaterService::pumpName()).
-		listen("MandatoryUpdateMachine::CheckingForUpdate", boost::bind(&MandatoryUpdateMachine::WaitingForDownload::onEvent, this, _1));
-}
-
-
-void MandatoryUpdateMachine::WaitingForDownload::exit(void)
-{
-	mProgressView->setVisible(false);
-}
-
-
-bool MandatoryUpdateMachine::WaitingForDownload::onEvent(LLSD const & event)
-{
-	switch(event["type"].asInteger()) {
-		case LLUpdaterService::DOWNLOAD_COMPLETE:
-			mMachine.setCurrentState(new ReadyToInstall(mMachine));
-			break;
-		case LLUpdaterService::DOWNLOAD_ERROR:
-			mMachine.setCurrentState(new Error(mMachine));
-			break;
-		case LLUpdaterService::PROGRESS: {
-			double downloadSize = event["download_size"].asReal();
-			double bytesDownloaded = event["bytes_downloaded"].asReal();
-			mProgressView->setPercent(100. * bytesDownloaded / downloadSize);
-			break;
-		}
-		default:
-			break;
-	}
-
-	return false;
-}
-
-
-
 // LLLoginInstance
 //-----------------------------------------------------------------------------
 
@@ -484,11 +82,9 @@ LLLoginInstance::LLLoginInstance() :
 	mLoginModule(new LLLogin()),
 	mNotifications(NULL),
 	mLoginState("offline"),
-	mSkipOptionalUpdate(false),
 	mAttemptComplete(false),
 	mTransferRate(0.0f),
-	mDispatcher("LLLoginInstance", "change"),
-	mUpdaterService(0)
+	mDispatcher("LLLoginInstance", "change")
 {
 	mLoginModule->getEventPump().listen("lllogininstance", 
 		boost::bind(&LLLoginInstance::handleLoginEvent, this, _1));
@@ -598,13 +194,14 @@ void LLLoginInstance::constructAuthParams(LLPointer<LLCredential> user_credentia
 	
 	LLSD request_params;
 
-	unsigned char hashed_unique_id_string[MD5HEX_STR_SIZE];
-	if ( ! llHashedUniqueID(hashed_unique_id_string) )
-	{
-		LL_WARNS() << "Not providing a unique id in request params" << LL_ENDL;
+    unsigned char hashed_unique_id_string[MD5HEX_STR_SIZE];
+    if ( ! llHashedUniqueID(hashed_unique_id_string) )
+    {
+
+		LL_WARNS("LLLogin") << "Not providing a unique id in request params" << LL_ENDL;
+
 	}
 	request_params["start"] = construct_start_string();
-	request_params["skipoptional"] = mSkipOptionalUpdate;
 	request_params["agree_to_tos"] = false; // Always false here. Set true in 
 	request_params["read_critical"] = false; // handleTOSResponse
 	request_params["last_exec_event"] = mLastExecEvent;
@@ -651,7 +248,7 @@ bool LLLoginInstance::handleLoginEvent(const LLSD& event)
 
 	if(!(event.has("state") && event.has("change") && event.has("progress")))
 	{
-		LL_ERRS() << "Unknown message from LLLogin: " << event << LL_ENDL;
+		LL_ERRS("LLLogin") << "Unknown message from LLLogin: " << event << LL_ENDL;
 	}
 
 	mLoginState = event["state"].asString();
@@ -672,105 +269,109 @@ bool LLLoginInstance::handleLoginEvent(const LLSD& event)
 
 void LLLoginInstance::handleLoginFailure(const LLSD& event)
 {
-	
+    // Login has failed. 
+    // Figure out why and respond...
+    LLSD response = event["data"];
+    std::string reason_response = response["reason"].asString();
+    std::string message_response = response["message"].asString();
+    LL_DEBUGS("LLLogin") << "reason " << reason_response
+                         << " message " << message_response
+                         << LL_ENDL;
+    // For the cases of critical message or TOS agreement,
+    // start the TOS dialog. The dialog response will be handled
+    // by the LLLoginInstance::handleTOSResponse() callback.
+    // The callback intiates the login attempt next step, either 
+    // to reconnect or to end the attempt in failure.
+    if(reason_response == "tos")
+    {
+        LL_INFOS("LLLogin") << " ToS" << LL_ENDL;
+
+        LLSD data(LLSD::emptyMap());
+        data["message"] = message_response;
+        data["reply_pump"] = TOS_REPLY_PUMP;
+        if (gViewerWindow)
+            gViewerWindow->setShowProgress(FALSE);
+        LLFloaterReg::showInstance("message_tos", data);
+        LLEventPumps::instance().obtain(TOS_REPLY_PUMP)
+            .listen(TOS_LISTENER_NAME,
+                    boost::bind(&LLLoginInstance::handleTOSResponse, 
+                                this, _1, "agree_to_tos"));
+    }
+    else if(reason_response == "critical")
+    {
+        LL_INFOS("LLLogin") << "LLLoginInstance::handleLoginFailure Crit" << LL_ENDL;
+
+        LLSD data(LLSD::emptyMap());
+        data["message"] = message_response;
+        data["reply_pump"] = TOS_REPLY_PUMP;
+        if(response.has("error_code"))
+        {
+            data["error_code"] = response["error_code"];
+        }
+        if(response.has("certificate"))
+        {
+            data["certificate"] = response["certificate"];
+        }
+        
+        if (gViewerWindow)
+            gViewerWindow->setShowProgress(FALSE);
+
+        LLFloaterReg::showInstance("message_critical", data);
+        LLEventPumps::instance().obtain(TOS_REPLY_PUMP)
+            .listen(TOS_LISTENER_NAME,
+                    boost::bind(&LLLoginInstance::handleTOSResponse, 
+                                this, _1, "read_critical"));
+    }
+    else if(reason_response == "update")
+    {
+        // This shouldn't happen - the viewer manager should have forced an update; 
+        // possibly the user ran the viewer directly and bypassed the update check
+        std::string required_version = response["message_args"]["VERSION"];
+        LL_WARNS("LLLogin") << "Login failed because an update to version " << required_version << " is required." << LL_ENDL;
 
-	// Login has failed. 
-	// Figure out why and respond...
-	LLSD response = event["data"];
-	std::string reason_response = response["reason"].asString();
-	std::string message_response = response["message"].asString();
-	// For the cases of critical message or TOS agreement,
-	// start the TOS dialog. The dialog response will be handled
-	// by the LLLoginInstance::handleTOSResponse() callback.
-	// The callback intiates the login attempt next step, either 
-	// to reconnect or to end the attempt in failure.
-	if(reason_response == "tos")
-	{
-		LL_INFOS() << "LLLoginInstance::handleLoginFailure ToS" << LL_ENDL;
-
-		LLSD data(LLSD::emptyMap());
-		data["message"] = message_response;
-		data["reply_pump"] = TOS_REPLY_PUMP;
-		if (gViewerWindow)
-			gViewerWindow->setShowProgress(FALSE);
-		LLFloaterReg::showInstance("message_tos", data);
-		LLEventPumps::instance().obtain(TOS_REPLY_PUMP)
-			.listen(TOS_LISTENER_NAME,
-					boost::bind(&LLLoginInstance::handleTOSResponse, 
-								this, _1, "agree_to_tos"));
-	}
-	else if(reason_response == "critical")
-	{
-		LL_INFOS() << "LLLoginInstance::handleLoginFailure Crit" << LL_ENDL;
+        if (gViewerWindow)
+            gViewerWindow->setShowProgress(FALSE);
 
-		LLSD data(LLSD::emptyMap());
-		data["message"] = message_response;
-		data["reply_pump"] = TOS_REPLY_PUMP;
-		if(response.has("error_code"))
-		{
-			data["error_code"] = response["error_code"];
-		}
-		if(response.has("certificate"))
-		{
-			data["certificate"] = response["certificate"];
-		}
-		
-		if (gViewerWindow)
-			gViewerWindow->setShowProgress(FALSE);
-
-		LLFloaterReg::showInstance("message_critical", data);
-		LLEventPumps::instance().obtain(TOS_REPLY_PUMP)
-			.listen(TOS_LISTENER_NAME,
-					boost::bind(&LLLoginInstance::handleTOSResponse, 
-								this, _1, "read_critical"));
-	}
-	else if(reason_response == "update" || gSavedSettings.getBOOL("ForceMandatoryUpdate"))
-	{
-		LL_INFOS() << "LLLoginInstance::handleLoginFailure update" << LL_ENDL;
+        LLSD data(LLSD::emptyMap());
+        data["VERSION"] = required_version;
+        LLNotificationsUtil::add("RequiredUpdate", data, LLSD::emptyMap(), boost::bind(&LLLoginInstance::handleLoginDisallowed, this, _1, _2));
+    }
+    else if(   reason_response == "key"
+            || reason_response == "presence"
+            || reason_response == "connect"
+            )
+    {
+        // these are events that have already been communicated elsewhere
+        attemptComplete();
+    }
+    else
+    {   
+        LL_WARNS("LLLogin") << "Login failed for an unknown reason: " << LLSDOStreamer<LLSDNotationFormatter>(response) << LL_ENDL;
 
-		gSavedSettings.setBOOL("ForceMandatoryUpdate", FALSE);
-		updateApp(true, message_response);
-	}
-	else if(reason_response == "optional")
-	{
-		LL_INFOS() << "LLLoginInstance::handleLoginFailure optional" << LL_ENDL;
+        if (gViewerWindow)
+            gViewerWindow->setShowProgress(FALSE);
 
-		updateApp(false, message_response);
-	}
-	else
-	{	
-		LL_INFOS() << "LLLoginInstance::handleLoginFailure attemptComplete" << LL_ENDL;
-		attemptComplete();
-	}	
+        LLNotificationsUtil::add("LoginFailedUnknown", LLSD::emptyMap(), LLSD::emptyMap(), boost::bind(&LLLoginInstance::handleLoginDisallowed, this, _1, _2));
+    }   
 }
 
-void LLLoginInstance::handleLoginSuccess(const LLSD& event)
+void LLLoginInstance::handleLoginDisallowed(const LLSD& notification, const LLSD& response)
 {
-	LL_INFOS() << "LLLoginInstance::handleLoginSuccess" << LL_ENDL;
-
-	if(gSavedSettings.getBOOL("ForceMandatoryUpdate"))
-	{
-		LLSD response = event["data"];
-		std::string message_response = response["message"].asString();
+    attemptComplete();
+}
 
-		// Testing update...
-		gSavedSettings.setBOOL("ForceMandatoryUpdate", FALSE);
+void LLLoginInstance::handleLoginSuccess(const LLSD& event)
+{
+	LL_INFOS("LLLogin") << "LLLoginInstance::handleLoginSuccess" << LL_ENDL;
 
-		// Don't confuse startup by leaving login "online".
-		mLoginModule->disconnect(); 
-		updateApp(true, message_response);
-	}
-	else
-	{
-		attemptComplete();
-	}
+	attemptComplete();
 }
 
 void LLLoginInstance::handleDisconnect(const LLSD& event)
 {
     // placeholder
 
-	LL_INFOS() << "LLLoginInstance::handleDisconnect placeholder " << LL_ENDL;
+	LL_INFOS("LLLogin") << "LLLoginInstance::handleDisconnect placeholder " << LL_ENDL;
 }
 
 void LLLoginInstance::handleIndeterminate(const LLSD& event)
@@ -784,7 +385,7 @@ void LLLoginInstance::handleIndeterminate(const LLSD& event)
 	LLSD message = event.get("data").get("message");
 	if(message.isDefined())
 	{
-		LL_INFOS() << "LLLoginInstance::handleIndeterminate " << message.asString() << LL_ENDL;
+		LL_INFOS("LLLogin") << "LLLoginInstance::handleIndeterminate " << message.asString() << LL_ENDL;
 
 		LLSD progress_update;
 		progress_update["desc"] = message;
@@ -796,7 +397,7 @@ bool LLLoginInstance::handleTOSResponse(bool accepted, const std::string& key)
 {
 	if(accepted)
 	{	
-		LL_INFOS() << "LLLoginInstance::handleTOSResponse: accepted" << LL_ENDL;
+		LL_INFOS("LLLogin") << "LLLoginInstance::handleTOSResponse: accepted" << LL_ENDL;
 
 		// Set the request data to true and retry login.
 		mRequestData["params"][key] = true; 
@@ -804,7 +405,7 @@ bool LLLoginInstance::handleTOSResponse(bool accepted, const std::string& key)
 	}
 	else
 	{
-		LL_INFOS() << "LLLoginInstance::handleTOSResponse: attemptComplete" << LL_ENDL;
+		LL_INFOS("LLLogin") << "LLLoginInstance::handleTOSResponse: attemptComplete" << LL_ENDL;
 
 		attemptComplete();
 	}
@@ -814,134 +415,6 @@ bool LLLoginInstance::handleTOSResponse(bool accepted, const std::string& key)
 }
 
 
-void LLLoginInstance::updateApp(bool mandatory, const std::string& auth_msg)
-{
-	if(mandatory)
-	{
-		gViewerWindow->setShowProgress(false);
-		MandatoryUpdateMachine * machine = new MandatoryUpdateMachine(*this, *mUpdaterService);
-		mUpdateStateMachine.reset(machine);
-		machine->start();
-		return;
-	}
-	
-	// store off config state, as we might quit soon
-	gSavedSettings.saveToFile(gSavedSettings.getString("ClientSettingsFile"), TRUE);	
-	LLUIColorTable::instance().saveUserSettings();
-
-	std::ostringstream message;
-	std::string msg;
-	if (!auth_msg.empty())
-	{
-		msg = "(" + auth_msg + ") \n";
-	}
-
-	LLSD args;
-	args["MESSAGE"] = msg;
-	
-	LLSD payload;
-	payload["mandatory"] = mandatory;
-
-	/*
-	 * We're constructing one of the following 9 strings here:
-	 *   "DownloadWindowsMandatory"
-	 *	 "DownloadWindowsReleaseForDownload"
-	 *	 "DownloadWindows"
-	 *	 "DownloadMacMandatory"
-	 *	 "DownloadMacReleaseForDownload"
-	 *	 "DownloadMac"
-	 *	 "DownloadLinuxMandatory"
-	 *	 "DownloadLinuxReleaseForDownload"
-	 *	 "DownloadLinux"
- 	 *
-	 * I've called them out explicitly in this comment so that they can be grepped for.
-	 */
-	std::string notification_name = "Download";
-	
-#if LL_WINDOWS
-	notification_name += "Windows";
-#elif LL_DARWIN
-	notification_name += "Mac";
-#else
-	notification_name += "Linux";
-#endif
-	
-	if (mandatory)
-	{
-		notification_name += "Mandatory";
-	}
-	else
-	{
-#if LL_RELEASE_FOR_DOWNLOAD
-		notification_name += "ReleaseForDownload";
-#endif
-	}
-
-	if(mNotifications)
-	{
-		mNotifications->add(notification_name, args, payload, 
-			boost::bind(&LLLoginInstance::updateDialogCallback, this, _1, _2));
-
-		gViewerWindow->setShowProgress(false);
-	}
-}
-
-bool LLLoginInstance::updateDialogCallback(const LLSD& notification, const LLSD& response)
-{
-	S32 option = LLNotification::getSelectedOption(notification, response);
-	std::string update_exe_path;
-	bool mandatory = notification["payload"]["mandatory"].asBoolean();
-
-#if !LL_RELEASE_FOR_DOWNLOAD
-	if (option == 2)
-	{
-		// This condition attempts to skip the 
-		// update if using a dev build.
-		// The relog probably won't work if the 
-		// update is mandatory. :)
-
-	    // *REMOVE:Mani - Saving for reference...
-		//LLStartUp::setStartupState( STATE_LOGIN_AUTH_INIT ); 
-		mSkipOptionalUpdate = true;
-		reconnect();
-		return false;
-	}
-#endif
-
-	if (option == 1)
-	{
-		// ...user doesn't want to do it
-		if (mandatory)
-		{
-			// Mandatory update, user chose to not to update...
-			// The login attemp is complete, startup should 
-			// quit when detecting this.
-			attemptComplete();
-
-			// *REMOVE:Mani - Saving for reference...
-			//LLAppViewer::instance()->forceQuit();
-			// // Bump them back to the login screen.
-			// //reset_login();
-		}
-		else
-		{
-			// Optional update, user chose to skip
-			mSkipOptionalUpdate = true;
-			reconnect();
-		}
-		return false;
-	}
-	
- 	if(mUpdaterLauncher)
-  	{
- 		mUpdaterLauncher();
-  	}
-  
- 	attemptComplete();
-
-	return false;
-}
-
 std::string construct_start_string()
 {
 	std::string start;