ESC-211 Metrics data sink - fix delivery by viewer

The TextureFetch thread was still stalling out due to
a different path that determines whether there is work
or not in the thread (uses getPending()) and that had
to be harmonized with the changes to runCondition().
I'm not happy with this solution but a refactor of the
LLThread tree isn't in the cards right now.

1 files changed, 78 insertions, 11 deletions

diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 3793085e55..dd84290e90 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -568,6 +568,14 @@ public:
 	LLSD * mReportMain;
 };
 
+/*
+ * Count of POST requests outstanding.  We maintain the count
+ * indirectly in the CURL request responder's ctor and dtor and
+ * use it when determining whether or not to sleep the flag.  Can't
+ * use the LLCurl module's request counter as it isn't thread compatible.
+ */
+LLAtomic32<S32> curl_post_request_count = 0;
+    
 } // end of anonymous namespace
 
 
@@ -2084,6 +2092,33 @@ bool LLTextureFetch::updateRequestPriority(const LLUUID& id, F32 priority)
 	return res;
 }
 
+// Replicates and expands upon the base class's
+// getPending() implementation.  getPending() and
+// runCondition() replicate one another's logic to
+// an extent and are sometimes used for the same
+// function (deciding whether or not to sleep/pause
+// a thread).  So the implementations need to stay
+// in step, at least until this can be refactored and
+// the redundancy eliminated.
+//
+// May be called from any thread
+
+//virtual
+S32 LLTextureFetch::getPending()
+{
+	S32 res;
+	lockData();
+    {
+        LLMutexLock lock(&mQueueMutex);
+        
+        res = mRequestQueue.size();
+        res += curl_post_request_count;
+        res += mCommands.size();
+    }
+	unlockData();
+	return res;
+}
+
 // virtual
 bool LLTextureFetch::runCondition()
 {
@@ -2100,7 +2135,12 @@ bool LLTextureFetch::runCondition()
 		
 		have_no_commands = mCommands.empty();
 	}
-	return ! (have_no_commands && mRequestQueue.empty() && mIdleThread);
+	
+    bool have_no_curl_requests(0 == curl_post_request_count);
+	
+	return ! (have_no_commands
+             && have_no_curl_requests
+             && (mRequestQueue.empty() && mIdleThread));
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -2116,7 +2156,7 @@ void LLTextureFetch::commonUpdate()
 	if (processed > 0)
 	{
 		lldebugs << "processed: " << processed << " messages." << llendl;
-	}	
+	}
 }
 
 
@@ -2766,31 +2806,56 @@ TFReqSendMetrics::doWork(LLTextureFetch * fetcher)
 	 * the referenced data is part of a pseudo-closure for
 	 * this responder rather than being required for correct
 	 * operation.
+     *
+     * We don't try very hard with the POST request.  We give
+     * it one shot and that's more-or-less it.  With a proper
+     * refactoring of the LLQueuedThread usage, these POSTs
+     * could be put in a request object and made more reliable.
 	 */
 	class lcl_responder : public LLCurl::Responder
 	{
 	public:
-		lcl_responder(volatile bool & reporting_break,
+		lcl_responder(S32 expected_sequence,
+                      volatile const S32 & live_sequence,
+                      volatile bool & reporting_break,
 					  volatile bool & reporting_started)
-			: LLHTTPClient::Responder(),
+			: LLCurl::Responder(),
+              mExpectedSequence(expected_sequence),
+              mLiveSequence(live_sequence),
 			  mReportingBreak(reporting_break),
 			  mReportingStarted(reporting_started)
-			{}
+			{
+                curl_post_request_count++;
+            }
+        
+        ~lcl_responder()
+            {
+                curl_post_request_count--;
+            }
 
 		// virtual
 		void error(U32 status_num, const std::string & reason)
 			{
-				mReportingBreak = true;
+                if (mLiveSequence == mExpectedSequence)
+                {
+                    mReportingBreak = true;
+                }
 			}
 
 		// virtual
 		void result(const LLSD & content)
 			{
-				mReportingBreak = false;
-				mReportingStarted = true;
+                if (mLiveSequence == mExpectedSequence)
+                {
+                    mReportingBreak = false;
+                    mReportingStarted = true;
+                }
 			}
+        
 
 	private:
+        S32 mExpectedSequence;
+        volatile const S32 & mLiveSequence;
 		volatile bool & mReportingBreak;
 		volatile bool & mReportingStarted;
 	};
@@ -2799,8 +2864,8 @@ TFReqSendMetrics::doWork(LLTextureFetch * fetcher)
 		return true;
 
 	static volatile bool reporting_started(false);
-	static S32 report_sequence(0);
-
+	static volatile S32 report_sequence(0);
+    
 	// We've already taken over ownership of the LLSD at this point
 	// and can do normal LLSD sharing operations at this point.  But
 	// still being careful, regardless.
@@ -2826,7 +2891,9 @@ TFReqSendMetrics::doWork(LLTextureFetch * fetcher)
 		fetcher->getCurlRequest().post(mCapsURL,
 									   headers,
 									   thread1_stats,
-									   new lcl_responder(LLTextureFetch::svMetricsDataBreak,
+									   new lcl_responder(report_sequence,
+                                                         report_sequence,
+                                                         LLTextureFetch::svMetricsDataBreak,
 														 reporting_started));
 	}
 	else