From 6b8c814df3141fa705b9921ba0a73aeaa3fe63b6 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Thu, 19 Mar 2015 17:01:21 -0700
Subject: Adding new HTTP handling for material manager.

---
 indra/llmessage/llcorehttputil.h | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index d40172bc7a..7c5a5aea61 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -109,6 +109,31 @@ LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
 									   LLCore::HttpHeaders * headers,
 									   LLCore::HttpHandler * handler);
 
+/// Issue a standard HttpRequest::requestPut() call but using
+/// and LLSD object as the request body.  Conventions are the
+/// same as with that method.  Caller is expected to provide
+/// an HttpHeaders object with a correct 'Content-Type:' header.
+/// One will not be provided by this call.
+///
+/// @return				If request is successfully issued, the
+///						HttpHandle representing the request.
+///						On error, LLCORE_HTTP_HANDLE_INVALID
+///						is returned and caller can fetch detailed
+///						status with the getStatus() method on the
+///						request object.  In case of error, no
+///						request is queued and caller may need to
+///						perform additional cleanup such as freeing
+///						a now-useless HttpHandler object.
+///
+LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
+	LLCore::HttpRequest::policy_t policy_id,
+	LLCore::HttpRequest::priority_t priority,
+	const std::string & url,
+	const LLSD & body,
+	LLCore::HttpOptions * options,
+	LLCore::HttpHeaders * headers,
+	LLCore::HttpHandler * handler);
+
 } // end namespace LLCoreHttpUtil
 
 
-- 
cgit v1.2.3


From 9d676ce5b97d7ce09630d7d6ab8abd562b958cae Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Fri, 20 Mar 2015 13:16:25 -0700
Subject: Clean up and use policies for Material transfer.

---
 indra/llmessage/llcorehttputil.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 7c5a5aea61..8e26f413fe 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -109,6 +109,15 @@ LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
 									   LLCore::HttpHeaders * headers,
 									   LLCore::HttpHandler * handler);
 
+LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
+	LLCore::HttpRequest::policy_t policy_id,
+	LLCore::HttpRequest::priority_t priority,
+	const std::string & url,
+	const LLSD & body,
+	LLCore::HttpOptions::ptr_t & options,
+	LLCore::HttpHeaders::ptr_t & headers,
+	LLCore::HttpHandler * handler);
+
 /// Issue a standard HttpRequest::requestPut() call but using
 /// and LLSD object as the request body.  Conventions are the
 /// same as with that method.  Caller is expected to provide
@@ -134,6 +143,15 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
 	LLCore::HttpHeaders * headers,
 	LLCore::HttpHandler * handler);
 
+LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
+	LLCore::HttpRequest::policy_t policy_id,
+	LLCore::HttpRequest::priority_t priority,
+	const std::string & url,
+	const LLSD & body,
+	LLCore::HttpOptions::ptr_t & options,
+	LLCore::HttpHeaders::ptr_t & headers,
+	LLCore::HttpHandler * handler);
+
 } // end namespace LLCoreHttpUtil
 
 
-- 
cgit v1.2.3


From edc1439bd633bdac183fbecc131edd55074b5442 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Wed, 1 Apr 2015 16:37:00 -0700
Subject: Added AvatarNameCache as coroutine, with LLCore::HttpHandler to
 respond correctly to Event Pumps. Added get/setRequestURL() to
 LLCore::HttpResponse Removed URI from the HttpSDHandler.

---
 indra/llmessage/llcorehttputil.h | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 8e26f413fe..0bc102a0a3 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -39,6 +39,7 @@
 #include "bufferarray.h"
 #include "bufferstream.h"
 #include "llsd.h"
+#include "llevents.h"
 
 ///
 /// The base llcorehttp library implements many HTTP idioms
@@ -152,6 +153,35 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
 	LLCore::HttpHeaders::ptr_t & headers,
 	LLCore::HttpHandler * handler);
 
+/// The HttpCoroHandler is a specialization of the LLCore::HttpHandler for 
+/// interacting with coroutines. When the request is completed the response 
+/// will be posted onto the supplied Event Pump.
+/// 
+/// The LLSD posted back to the coroutine will have the following additions:
+/// llsd["http_result"] -+- ["message"] - An error message returned from the HTTP status
+///                      +- ["status"]  - The status code associated with the HTTP call
+///                      +- ["success"] - Success of failure of the HTTP call and LLSD parsing.
+///                      +- ["type"]    - The LLCore::HttpStatus type associted with the HTTP call
+///                      +- ["url"]     - The URL used to make the call.
+///                      +- ["headers"] - A map of name name value pairs with the HTTP headers.
+///                      
+
+/// 
+class HttpCoroHandler : public LLCore::HttpHandler
+{
+public:
+    HttpCoroHandler(LLEventStream &reply);
+
+    virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
+
+    typedef boost::shared_ptr<HttpCoroHandler> ptr_t;
+
+private:
+    void buildStatusEntry(LLCore::HttpResponse *response, LLCore::HttpStatus status, LLSD &result);
+
+    LLEventStream &mReplyPump;
+};
+
 } // end namespace LLCoreHttpUtil
 
 
-- 
cgit v1.2.3


From 17641c8427d05c4cde1fadd2ca059264d89bc818 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Fri, 3 Apr 2015 14:23:31 -0700
Subject: Added a class to automate pumping the HttpRequest on the mainloop.
 Converted AccountingCostManager to use the new LLCore::Http library and
 coroutines.

---
 indra/llmessage/llcorehttputil.h | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 0bc102a0a3..4ae6e112b3 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -165,8 +165,6 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
 ///                      +- ["url"]     - The URL used to make the call.
 ///                      +- ["headers"] - A map of name name value pairs with the HTTP headers.
 ///                      
-
-/// 
 class HttpCoroHandler : public LLCore::HttpHandler
 {
 public:
@@ -182,6 +180,22 @@ private:
     LLEventStream &mReplyPump;
 };
 
+/// The HttpRequestPumper is a utility class. When constructed it will poll the 
+/// supplied HttpRequest once per frame until it is destroyed.
+/// 
+class HttpRequestPumper
+{
+public:
+    HttpRequestPumper(const LLCore::HttpRequest::ptr_t &request);
+    ~HttpRequestPumper();
+
+private:
+    bool                       pollRequest(const LLSD&);
+
+    LLTempBoundListener        mBoundListener;
+    LLCore::HttpRequest::ptr_t mHttpRequest;
+};
+
 } // end namespace LLCoreHttpUtil
 
 
-- 
cgit v1.2.3


From 8a76284e488227b9ff83917cdec2ea011c088527 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Tue, 7 Apr 2015 10:30:10 -0700
Subject: Results from code review with Nat. Consolidate some of the
 coroutine/http code into a single adapter.

---
 indra/llmessage/llcorehttputil.h | 47 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 46 insertions(+), 1 deletion(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 4ae6e112b3..10f46dd477 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -40,6 +40,8 @@
 #include "bufferstream.h"
 #include "llsd.h"
 #include "llevents.h"
+#include "llcoros.h"
+#include "lleventcoro.h"
 
 ///
 /// The base llcorehttp library implements many HTTP idioms
@@ -174,6 +176,7 @@ public:
 
     typedef boost::shared_ptr<HttpCoroHandler> ptr_t;
 
+    void writeStatusCodes(LLCore::HttpStatus status, const std::string &url, LLSD &result);
 private:
     void buildStatusEntry(LLCore::HttpResponse *response, LLCore::HttpStatus status, LLSD &result);
 
@@ -196,7 +199,49 @@ private:
     LLCore::HttpRequest::ptr_t mHttpRequest;
 };
 
-} // end namespace LLCoreHttpUtil
+/// An adapter to handle some of the boilerplate code surrounding HTTP and coroutine 
+/// interaction.
+/// 
+/// Construct an HttpCoroutineAdapter giving it a name and policy Id. After 
+/// any application specific setup call the post, put or get method.  The request 
+/// will be automatically pumped and the method will return with an LLSD describing
+/// the result of the operation.  See HttpCoroHandler for a description of the 
+/// decoration done to the returned LLSD.
+class HttpCoroutineAdapter
+{
+public:
+    HttpCoroutineAdapter(const std::string &name, LLCore::HttpRequest::policy_t policyId, 
+            LLCore::HttpRequest::priority_t priority = 0L);
+    ~HttpCoroutineAdapter();
+
+    /// Execute a Post transaction on the supplied URL and yield execution of 
+    /// the coroutine until a result is available.
+    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t & request,
+        const std::string & url, const LLSD & body, 
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(), 
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t());
+
+    /// Execute a Put transaction on the supplied URL and yield execution of 
+    /// the coroutine until a result is available.
+    LLSD putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t & request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t());
+
+    /// Execute a Get transaction on the supplied URL and yield execution of 
+    /// the coroutine until a result is available.
+    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t & request,
+        const std::string & url,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t());
 
+private:
+
+    std::string                     mAdapterName;
+    LLCore::HttpRequest::priority_t mPriority;
+    LLCore::HttpRequest::policy_t   mPolicyId;
+};
+
+} // end namespace LLCoreHttpUtil
 
 #endif // LL_LLCOREHTTPUTIL_H
-- 
cgit v1.2.3


From 1c91c8a106a78f2087a3fb4312e428a0128283b4 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Wed, 8 Apr 2015 10:17:34 -0700
Subject: Adding weak pointer support. Event polling as a coroutine.
 (incomplete) Groundwork for canceling HttpCoroutineAdapter yields.

---
 indra/llmessage/llcorehttputil.h | 30 ++++++++++++++++++++++++------
 1 file changed, 24 insertions(+), 6 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 10f46dd477..33cc389c49 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -210,36 +210,54 @@ private:
 class HttpCoroutineAdapter
 {
 public:
+    typedef boost::shared_ptr<HttpCoroutineAdapter> ptr_t;
+    typedef boost::weak_ptr<HttpCoroutineAdapter>   wptr_t;
+
     HttpCoroutineAdapter(const std::string &name, LLCore::HttpRequest::policy_t policyId, 
             LLCore::HttpRequest::priority_t priority = 0L);
     ~HttpCoroutineAdapter();
 
     /// Execute a Post transaction on the supplied URL and yield execution of 
-    /// the coroutine until a result is available.
-    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t & request,
+    /// the coroutine until a result is available. 
+    /// Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body, 
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(), 
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t());
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
 
     /// Execute a Put transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
-    LLSD putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t & request,
+    /// Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t());
 
     /// Execute a Get transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
-    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t & request,
+    /// Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t());
 
+    ///
+    void cancelYieldingOperation();
+
 private:
+    static LLSD buildImmediateErrorResult(const LLCore::HttpRequest::ptr_t &request, 
+            const std::string &url, LLCoreHttpUtil::HttpCoroHandler::ptr_t &httpHandler);
 
     std::string                     mAdapterName;
     LLCore::HttpRequest::priority_t mPriority;
     LLCore::HttpRequest::policy_t   mPolicyId;
+
+    LLCore::HttpHandle              mYieldingHandle;
+    LLCore::HttpRequest::wptr_t     mWeakRequest;
+
 };
 
 } // end namespace LLCoreHttpUtil
-- 
cgit v1.2.3


From 93382ee0c0c570e58b17af5f43f9738d773e8add Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Wed, 8 Apr 2015 14:29:37 -0700
Subject: Moved some LLEventPolling internal classes to a named namespace
 Canceling outstanding polling transactions

---
 indra/llmessage/llcorehttputil.h | 37 +++++++++++++++++++++++++------------
 1 file changed, 25 insertions(+), 12 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 33cc389c49..471710f61b 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -170,13 +170,16 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
 class HttpCoroHandler : public LLCore::HttpHandler
 {
 public:
+    typedef boost::shared_ptr<HttpCoroHandler>  ptr_t;
+    typedef boost::weak_ptr<HttpCoroHandler>    wptr_t;
+
     HttpCoroHandler(LLEventStream &reply);
 
     virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
 
-    typedef boost::shared_ptr<HttpCoroHandler> ptr_t;
+    static void writeStatusCodes(LLCore::HttpStatus status, const std::string &url, LLSD &result);
+    static LLCore::HttpStatus getStatusFromLLSD(const LLSD &httpResults);
 
-    void writeStatusCodes(LLCore::HttpStatus status, const std::string &url, LLSD &result);
 private:
     void buildStatusEntry(LLCore::HttpResponse *response, LLCore::HttpStatus status, LLSD &result);
 
@@ -219,7 +222,8 @@ public:
 
     /// Execute a Post transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available. 
-    /// Note: the request's smart pointer is passed by value so that it will
+    /// 
+    /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
     LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body, 
@@ -228,28 +232,34 @@ public:
 
     /// Execute a Put transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
-    /// Note: the request's smart pointer is passed by value so that it will
+    /// 
+    /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
     LLSD putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t());
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
 
     /// Execute a Get transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
-    /// Note: the request's smart pointer is passed by value so that it will
+    /// 
+    /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
     LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t());
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
 
     ///
     void cancelYieldingOperation();
 
 private:
-    static LLSD buildImmediateErrorResult(const LLCore::HttpRequest::ptr_t &request, 
-            const std::string &url, LLCoreHttpUtil::HttpCoroHandler::ptr_t &httpHandler);
+    static LLSD buildImmediateErrorResult(const LLCore::HttpRequest::ptr_t &request, const std::string &url);
+
+    void saveState(LLCore::HttpHandle yieldingHandle, LLCore::HttpRequest::ptr_t &request,
+            HttpCoroHandler::ptr_t &handler);
+    void cleanState();
+
 
     std::string                     mAdapterName;
     LLCore::HttpRequest::priority_t mPriority;
@@ -257,9 +267,12 @@ private:
 
     LLCore::HttpHandle              mYieldingHandle;
     LLCore::HttpRequest::wptr_t     mWeakRequest;
-
+    HttpCoroHandler::wptr_t         mWeakHandler;
 };
 
+//-------------------------------------------------------------------------
+LLCore::HttpStatus getStatusFromLLSD(const LLSD &httpResults);
+
 } // end namespace LLCoreHttpUtil
 
 #endif // LL_LLCOREHTTPUTIL_H
-- 
cgit v1.2.3


From d0c85b6dd964164b6d92103ad65b5cd859197de2 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Fri, 10 Apr 2015 17:23:58 -0700
Subject: Adding support for DELETE, PATCH and COPY

---
 indra/llmessage/llcorehttputil.h | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 471710f61b..6fcf03b95c 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -155,6 +155,41 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
 	LLCore::HttpHeaders::ptr_t & headers,
 	LLCore::HttpHandler * handler);
 
+/// Issue a standard HttpRequest::requestPatch() call but using
+/// and LLSD object as the request body.  Conventions are the
+/// same as with that method.  Caller is expected to provide
+/// an HttpHeaders object with a correct 'Content-Type:' header.
+/// One will not be provided by this call.
+///
+/// @return				If request is successfully issued, the
+///						HttpHandle representing the request.
+///						On error, LLCORE_HTTP_HANDLE_INVALID
+///						is returned and caller can fetch detailed
+///						status with the getStatus() method on the
+///						request object.  In case of error, no
+///						request is queued and caller may need to
+///						perform additional cleanup such as freeing
+///						a now-useless HttpHandler object.
+///
+LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest * request,
+    LLCore::HttpRequest::policy_t policy_id,
+    LLCore::HttpRequest::priority_t priority,
+    const std::string & url,
+    const LLSD & body,
+    LLCore::HttpOptions * options,
+    LLCore::HttpHeaders * headers,
+    LLCore::HttpHandler * handler);
+
+LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
+    LLCore::HttpRequest::policy_t policy_id,
+    LLCore::HttpRequest::priority_t priority,
+    const std::string & url,
+    const LLSD & body,
+    LLCore::HttpOptions::ptr_t & options,
+    LLCore::HttpHeaders::ptr_t & headers,
+    LLCore::HttpHandler * handler);
+
+
 /// The HttpCoroHandler is a specialization of the LLCore::HttpHandler for 
 /// interacting with coroutines. When the request is completed the response 
 /// will be posted onto the supplied Event Pump.
-- 
cgit v1.2.3


From c4bcc83336c623b97e982443ce2f91d82d1a187d Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Thu, 16 Apr 2015 17:01:10 -0700
Subject: Facebook conversion.

---
 indra/llmessage/llcorehttputil.h | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 6fcf03b95c..cd137dbbe1 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -205,6 +205,7 @@ LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
 class HttpCoroHandler : public LLCore::HttpHandler
 {
 public:
+
     typedef boost::shared_ptr<HttpCoroHandler>  ptr_t;
     typedef boost::weak_ptr<HttpCoroHandler>    wptr_t;
 
@@ -248,6 +249,15 @@ private:
 class HttpCoroutineAdapter
 {
 public:
+    static const std::string HTTP_RESULTS;
+    static const std::string HTTP_RESULTS_SUCCESS;
+    static const std::string HTTP_RESULTS_TYPE;
+    static const std::string HTTP_RESULTS_STATUS;
+    static const std::string HTTP_RESULTS_MESSAGE;
+    static const std::string HTTP_RESULTS_URL;
+    static const std::string HTTP_RESULTS_HEADERS;
+    static const std::string HTTP_RESULTS_CONTENT;
+
     typedef boost::shared_ptr<HttpCoroutineAdapter> ptr_t;
     typedef boost::weak_ptr<HttpCoroutineAdapter>   wptr_t;
 
@@ -264,6 +274,25 @@ public:
         const std::string & url, const LLSD & body, 
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+        const std::string & url, LLCore::BufferArray::ptr_t rawbody,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return postAndYield(self, request, url, body,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+    }
+
+    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return postAndYield(self, request, url, rawbody, 
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+    }
 
     /// Execute a Put transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
@@ -285,6 +314,16 @@ public:
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
 
+    /// Execute a DELETE transaction on the supplied URL and yield execution of 
+    /// the coroutine until a result is available.
+    /// 
+    /// @Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD deleteAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+        const std::string & url,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+
     ///
     void cancelYieldingOperation();
 
-- 
cgit v1.2.3


From 27258d370be634630299a59ab9bea51e55b37bbb Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Mon, 20 Apr 2015 11:57:51 -0700
Subject: Flickr conversion.

---
 indra/llmessage/llcorehttputil.h | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index cd137dbbe1..1e2b50e189 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -261,8 +261,8 @@ public:
     typedef boost::shared_ptr<HttpCoroutineAdapter> ptr_t;
     typedef boost::weak_ptr<HttpCoroutineAdapter>   wptr_t;
 
-    HttpCoroutineAdapter(const std::string &name, LLCore::HttpRequest::policy_t policyId, 
-            LLCore::HttpRequest::priority_t priority = 0L);
+    HttpCoroutineAdapter(const std::string &name, LLCore::HttpRequest::policy_t policyId,
+        LLCore::HttpRequest::priority_t priority = 0L);
     ~HttpCoroutineAdapter();
 
     /// Execute a Post transaction on the supplied URL and yield execution of 
@@ -271,7 +271,7 @@ public:
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
     LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
-        const std::string & url, const LLSD & body, 
+        const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
     LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
@@ -290,7 +290,7 @@ public:
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postAndYield(self, request, url, rawbody, 
+        return postAndYield(self, request, url, rawbody,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
     }
 
@@ -313,6 +313,13 @@ public:
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return getAndYield(self, request, url,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+            headers);
+    }
 
     /// Execute a DELETE transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
-- 
cgit v1.2.3


From cd55655592b7518451d78b1ef229bce3316af420 Mon Sep 17 00:00:00 2001
From: Rider Linden <none@none>
Date: Thu, 30 Apr 2015 13:12:09 -0700
Subject: Crash logger changes to LLCore::Http

---
 indra/llmessage/llcorehttputil.h | 57 +++++++++++++++++++++++++++++++++++-----
 1 file changed, 51 insertions(+), 6 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 1e2b50e189..77b9163492 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -112,14 +112,30 @@ LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
 									   LLCore::HttpHeaders * headers,
 									   LLCore::HttpHandler * handler);
 
-LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
+inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
 	LLCore::HttpRequest::policy_t policy_id,
 	LLCore::HttpRequest::priority_t priority,
 	const std::string & url,
 	const LLSD & body,
 	LLCore::HttpOptions::ptr_t & options,
 	LLCore::HttpHeaders::ptr_t & headers,
-	LLCore::HttpHandler * handler);
+	LLCore::HttpHandler * handler)
+{
+    return requestPostWithLLSD(request.get(), policy_id, priority,
+        url, body, options.get(), headers.get(), handler);
+}
+
+inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
+    LLCore::HttpRequest::policy_t policy_id,
+    LLCore::HttpRequest::priority_t priority,
+    const std::string & url,
+    const LLSD & body,
+    LLCore::HttpHandler * handler)
+{
+    return requestPostWithLLSD(request.get(), policy_id, priority,
+        url, body, NULL, NULL, handler);
+}
+
 
 /// Issue a standard HttpRequest::requestPut() call but using
 /// and LLSD object as the request body.  Conventions are the
@@ -146,14 +162,29 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
 	LLCore::HttpHeaders * headers,
 	LLCore::HttpHandler * handler);
 
-LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
+inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
 	LLCore::HttpRequest::policy_t policy_id,
 	LLCore::HttpRequest::priority_t priority,
 	const std::string & url,
 	const LLSD & body,
 	LLCore::HttpOptions::ptr_t & options,
 	LLCore::HttpHeaders::ptr_t & headers,
-	LLCore::HttpHandler * handler);
+	LLCore::HttpHandler * handler)
+{
+    return requestPutWithLLSD(request.get(), policy_id, priority,
+        url, body, options.get(), headers.get(), handler);
+}
+
+inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
+    LLCore::HttpRequest::policy_t policy_id,
+    LLCore::HttpRequest::priority_t priority,
+    const std::string & url,
+    const LLSD & body,
+    LLCore::HttpHandler * handler)
+{
+    return requestPutWithLLSD(request.get(), policy_id, priority,
+        url, body, NULL, NULL, handler);
+}
 
 /// Issue a standard HttpRequest::requestPatch() call but using
 /// and LLSD object as the request body.  Conventions are the
@@ -180,15 +211,29 @@ LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest * request,
     LLCore::HttpHeaders * headers,
     LLCore::HttpHandler * handler);
 
-LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
+inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
     LLCore::HttpRequest::policy_t policy_id,
     LLCore::HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
     LLCore::HttpOptions::ptr_t & options,
     LLCore::HttpHeaders::ptr_t & headers,
-    LLCore::HttpHandler * handler);
+    LLCore::HttpHandler * handler)
+{
+    return requestPatchWithLLSD(request.get(), policy_id, priority,
+        url, body, options.get(), headers.get(), handler);
+}
 
+inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
+    LLCore::HttpRequest::policy_t policy_id,
+    LLCore::HttpRequest::priority_t priority,
+    const std::string & url,
+    const LLSD & body,
+    LLCore::HttpHandler * handler)
+{
+    return requestPatchWithLLSD(request.get(), policy_id, priority,
+        url, body, NULL, NULL, handler);
+}
 
 /// The HttpCoroHandler is a specialization of the LLCore::HttpHandler for 
 /// interacting with coroutines. When the request is completed the response 
-- 
cgit v1.2.3


From 3e004ce66e1fa07421c138a20eb0dba61c5b26b3 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Mon, 11 May 2015 16:52:02 -0700
Subject: Updated feature manager downloader to coroutine. Added "raw"
 coroutine handler (returns raw result as LLSD::Binary) and split out the guts
 of the get, put, etc methods. Moved getStatusFromLLSD from HttpCoroHandler
 into HttpCorutineAdapter

---
 indra/llmessage/llcorehttputil.h | 70 ++++++++++++++++++++++++++++------------
 1 file changed, 50 insertions(+), 20 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 77b9163492..e8e5f1b1aa 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -235,6 +235,7 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
         url, body, NULL, NULL, handler);
 }
 
+//=========================================================================
 /// The HttpCoroHandler is a specialization of the LLCore::HttpHandler for 
 /// interacting with coroutines. When the request is completed the response 
 /// will be posted onto the supplied Event Pump.
@@ -256,33 +257,26 @@ public:
 
     HttpCoroHandler(LLEventStream &reply);
 
-    virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
-
     static void writeStatusCodes(LLCore::HttpStatus status, const std::string &url, LLSD &result);
-    static LLCore::HttpStatus getStatusFromLLSD(const LLSD &httpResults);
 
-private:
-    void buildStatusEntry(LLCore::HttpResponse *response, LLCore::HttpStatus status, LLSD &result);
+    virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
 
-    LLEventStream &mReplyPump;
-};
+    inline LLEventStream &getReplyPump()
+    {
+        return mReplyPump;
+    }
 
-/// The HttpRequestPumper is a utility class. When constructed it will poll the 
-/// supplied HttpRequest once per frame until it is destroyed.
-/// 
-class HttpRequestPumper
-{
-public:
-    HttpRequestPumper(const LLCore::HttpRequest::ptr_t &request);
-    ~HttpRequestPumper();
+protected:
+    /// this method may modify the status value
+    virtual LLSD handleSuccess(LLCore::HttpResponse * response, LLCore::HttpStatus &status) = 0;
 
 private:
-    bool                       pollRequest(const LLSD&);
+    void buildStatusEntry(LLCore::HttpResponse *response, LLCore::HttpStatus status, LLSD &result);
 
-    LLTempBoundListener        mBoundListener;
-    LLCore::HttpRequest::ptr_t mHttpRequest;
+    LLEventStream &mReplyPump;
 };
 
+//=========================================================================
 /// An adapter to handle some of the boilerplate code surrounding HTTP and coroutine 
 /// interaction.
 /// 
@@ -302,6 +296,7 @@ public:
     static const std::string HTTP_RESULTS_URL;
     static const std::string HTTP_RESULTS_HEADERS;
     static const std::string HTTP_RESULTS_CONTENT;
+    static const std::string HTTP_RESULTS_RAW;
 
     typedef boost::shared_ptr<HttpCoroutineAdapter> ptr_t;
     typedef boost::weak_ptr<HttpCoroutineAdapter>   wptr_t;
@@ -366,6 +361,19 @@ public:
             headers);
     }
 
+    LLSD getRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+        const std::string & url,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+    LLSD getRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return getRawAndYield(self, request, url,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+            headers);
+    }
+
+
     /// Execute a DELETE transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
     /// 
@@ -379,6 +387,8 @@ public:
     ///
     void cancelYieldingOperation();
 
+    static LLCore::HttpStatus getStatusFromLLSD(const LLSD &httpResults);
+
 private:
     static LLSD buildImmediateErrorResult(const LLCore::HttpRequest::ptr_t &request, const std::string &url);
 
@@ -386,6 +396,28 @@ private:
             HttpCoroHandler::ptr_t &handler);
     void cleanState();
 
+    LLSD postAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
+        HttpCoroHandler::ptr_t &handler);
+
+    LLSD postAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
+        LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
+        HttpCoroHandler::ptr_t &handler);
+
+    LLSD putAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
+        HttpCoroHandler::ptr_t &handler);
+
+    LLSD getAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, LLCore::HttpOptions::ptr_t &options, 
+        LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
+
+    LLSD deleteAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, LLCore::HttpOptions::ptr_t &options,
+        LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
     std::string                     mAdapterName;
     LLCore::HttpRequest::priority_t mPriority;
@@ -396,8 +428,6 @@ private:
     HttpCoroHandler::wptr_t         mWeakHandler;
 };
 
-//-------------------------------------------------------------------------
-LLCore::HttpStatus getStatusFromLLSD(const LLSD &httpResults);
 
 } // end namespace LLCoreHttpUtil
 
-- 
cgit v1.2.3


From 723834737dc8bdb608f73c5d7fe5bdebfdaa59e5 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Tue, 12 May 2015 14:32:43 -0700
Subject: Added trivial case GET and POST to the CoreHTTP Utils converted
 llfloaterregioninfo to use coroutine's and new LLCore::HTTP

---
 indra/llmessage/llcorehttputil.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index e8e5f1b1aa..7d60bfbbaf 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -387,8 +387,17 @@ public:
     ///
     void cancelYieldingOperation();
 
+
     static LLCore::HttpStatus getStatusFromLLSD(const LLSD &httpResults);
 
+    /// Generic Get and post routines for HTTP via coroutines.
+    /// These static methods do all required setup for the GET or POST operation.
+    /// When the operation completes successfully they will put the success message in the log at INFO level, 
+    /// If the operation fails the failure message is written to the log at WARN level.
+    /// 
+    static void genericHttpGet(const std::string &url, const std::string &success = std::string(), const std::string &failure = std::string());
+    static void genericHttpPost(const std::string &url, const LLSD &postData, const std::string &success, const std::string &failure);
+
 private:
     static LLSD buildImmediateErrorResult(const LLCore::HttpRequest::ptr_t &request, const std::string &url);
 
@@ -419,6 +428,9 @@ private:
         const std::string & url, LLCore::HttpOptions::ptr_t &options,
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
+    static void genericGetCoro(LLCoros::self& self, std::string &url, std::string success, std::string failure);
+    static void genericPostCoro(LLCoros::self& self, std::string &url, LLSD postData, std::string success, std::string failure);
+
     std::string                     mAdapterName;
     LLCore::HttpRequest::priority_t mPriority;
     LLCore::HttpRequest::policy_t   mPolicyId;
-- 
cgit v1.2.3


From 9ec050a0673c28b25eeb28ae7926ff1070cbb4c3 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Thu, 14 May 2015 10:33:46 -0700
Subject: Make generic callback version of trivial GET/PUT methods.  Make
 message use these methods.

---
 indra/llmessage/llcorehttputil.h | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 7d60bfbbaf..73a51fe83a 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -387,16 +387,26 @@ public:
     ///
     void cancelYieldingOperation();
 
-
     static LLCore::HttpStatus getStatusFromLLSD(const LLSD &httpResults);
 
+    /// The convenience routines below can be provided with callback functors 
+    /// which will be invoked in the case of success or failure.  These callbacks
+    /// should match this form.
+    /// @sa callbackHttpGet
+    /// @sa callbackHttpPost
+    typedef boost::function<void (const LLSD &)> completionCallback_t;
+
+    static void callbackHttpGet(const std::string &url, completionCallback_t success = NULL, completionCallback_t failure = NULL);
+    static void callbackHttpPost(const std::string &url, const LLSD &postData, completionCallback_t success = NULL, completionCallback_t failure = NULL);
+
     /// Generic Get and post routines for HTTP via coroutines.
     /// These static methods do all required setup for the GET or POST operation.
     /// When the operation completes successfully they will put the success message in the log at INFO level, 
     /// If the operation fails the failure message is written to the log at WARN level.
     /// 
-    static void genericHttpGet(const std::string &url, const std::string &success = std::string(), const std::string &failure = std::string());
-    static void genericHttpPost(const std::string &url, const LLSD &postData, const std::string &success, const std::string &failure);
+    static void messageHttpGet(const std::string &url, const std::string &success = std::string(), const std::string &failure = std::string());
+    static void messageHttpPost(const std::string &url, const LLSD &postData, const std::string &success, const std::string &failure);
+
 
 private:
     static LLSD buildImmediateErrorResult(const LLCore::HttpRequest::ptr_t &request, const std::string &url);
@@ -428,8 +438,8 @@ private:
         const std::string & url, LLCore::HttpOptions::ptr_t &options,
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    static void genericGetCoro(LLCoros::self& self, std::string &url, std::string success, std::string failure);
-    static void genericPostCoro(LLCoros::self& self, std::string &url, LLSD postData, std::string success, std::string failure);
+    static void trivialGetCoro(LLCoros::self& self, std::string &url, completionCallback_t success, completionCallback_t failure);
+    static void trivialPostCoro(LLCoros::self& self, std::string &url, LLSD postData, completionCallback_t success, completionCallback_t failure);
 
     std::string                     mAdapterName;
     LLCore::HttpRequest::priority_t mPriority;
-- 
cgit v1.2.3


From a4741cecb2112f418c1d98ca63a261e707a856c3 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Mon, 18 May 2015 16:18:07 -0700
Subject: Changed Avatar picker to use coroutine for find. Fixed a stray
 reference (&) on URL that had crept into some coroutine definitions.

---
 indra/llmessage/llcorehttputil.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 73a51fe83a..35e5b0aa2d 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -438,8 +438,8 @@ private:
         const std::string & url, LLCore::HttpOptions::ptr_t &options,
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    static void trivialGetCoro(LLCoros::self& self, std::string &url, completionCallback_t success, completionCallback_t failure);
-    static void trivialPostCoro(LLCoros::self& self, std::string &url, LLSD postData, completionCallback_t success, completionCallback_t failure);
+    static void trivialGetCoro(LLCoros::self& self, std::string url, completionCallback_t success, completionCallback_t failure);
+    static void trivialPostCoro(LLCoros::self& self, std::string url, LLSD postData, completionCallback_t success, completionCallback_t failure);
 
     std::string                     mAdapterName;
     LLCore::HttpRequest::priority_t mPriority;
-- 
cgit v1.2.3


From c437a9c4ec865c38366c8057010d24311888ecb1 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 20 May 2015 17:37:27 -0700
Subject: Webprofile converted to coroutine. Added JSON->LLSD converter Added
 corohandler for JSON data

---
 indra/llmessage/llcorehttputil.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 35e5b0aa2d..d6219318f9 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -373,6 +373,18 @@ public:
             headers);
     }
 
+    LLSD getJsonAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+        const std::string & url,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+    LLSD getJsonndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return getJsonAndYield(self, request, url,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+            headers);
+    }
+
 
     /// Execute a DELETE transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
-- 
cgit v1.2.3


From 83543e556cba8753077c9f004bb0dc71b4509007 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 27 May 2015 17:15:01 -0700
Subject: Memory leak (extra ref) in webprofile Viewer media routines to
 coroutine. Post with raw respons in llcorehttputil LLCore::Http added headers
 only option (applies only on get)

---
 indra/llmessage/llcorehttputil.h | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index d6219318f9..213610e58e 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -334,6 +334,19 @@ public:
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
     }
 
+    LLSD postRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+        const std::string & url, LLCore::BufferArray::ptr_t rawbody,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+
+    LLSD postRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return postRawAndYield(self, request, url, rawbody,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+    }
+
     /// Execute a Put transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
     /// 
-- 
cgit v1.2.3


From 0d3fb07bfa205b65f242ef2b761e827ff30e42fe Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 3 Jun 2015 16:04:40 -0700
Subject: Remove vestigial httpclient.h include from files that no longer need
 it.

---
 indra/llmessage/llcorehttputil.h | 1 +
 1 file changed, 1 insertion(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 213610e58e..53c8112395 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -36,6 +36,7 @@
 #include "httpheaders.h"
 #include "httpoptions.h"
 #include "httphandler.h"
+#include "llhttpconstants.h" // *TODO: move to llcorehttp
 #include "bufferarray.h"
 #include "bufferstream.h"
 #include "llsd.h"
-- 
cgit v1.2.3


From d0d58c41b48f8a2a0e18610b577059ee8419be5c Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Thu, 4 Jun 2015 17:36:24 -0700
Subject: Default headers added. Group manager finished conversion. Outfit
 folders coverted.

---
 indra/llmessage/llcorehttputil.h | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 53c8112395..e6c9d2463c 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -286,6 +286,13 @@ private:
 /// will be automatically pumped and the method will return with an LLSD describing
 /// the result of the operation.  See HttpCoroHandler for a description of the 
 /// decoration done to the returned LLSD.
+/// 
+/// Posting through the adapter will automatically add the following headers to 
+/// the request if they have not been previously specified in a supplied 
+/// HttpHeaders object:
+///     "Accept=application/llsd+xml"
+///     "X-SecondLife-UDP-Listen-Port=###"
+///     
 class HttpCoroutineAdapter
 {
 public:
@@ -467,6 +474,8 @@ private:
     static void trivialGetCoro(LLCoros::self& self, std::string url, completionCallback_t success, completionCallback_t failure);
     static void trivialPostCoro(LLCoros::self& self, std::string url, LLSD postData, completionCallback_t success, completionCallback_t failure);
 
+    void checkDefaultHeaders(LLCore::HttpHeaders::ptr_t &headers);
+
     std::string                     mAdapterName;
     LLCore::HttpRequest::priority_t mPriority;
     LLCore::HttpRequest::policy_t   mPolicyId;
-- 
cgit v1.2.3


From cf4fec954ca46a139465144ccc3888b8fc7d41da Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Mon, 8 Jun 2015 17:29:01 -0700
Subject: Added a way to pass a policy Id to the coroadapter. Changed language,
 appearance, and maturity to conform to use the adapter rather than the
 SDHandler

---
 indra/llmessage/llcorehttputil.h | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index e6c9d2463c..e98399c985 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -427,10 +427,18 @@ public:
     /// should match this form.
     /// @sa callbackHttpGet
     /// @sa callbackHttpPost
-    typedef boost::function<void (const LLSD &)> completionCallback_t;
+    typedef boost::function<void(const LLSD &)> completionCallback_t;
 
-    static void callbackHttpGet(const std::string &url, completionCallback_t success = NULL, completionCallback_t failure = NULL);
-    static void callbackHttpPost(const std::string &url, const LLSD &postData, completionCallback_t success = NULL, completionCallback_t failure = NULL);
+    static void callbackHttpGet(const std::string &url, LLCore::HttpRequest::policy_t policyId, completionCallback_t success = NULL, completionCallback_t failure = NULL);
+    static void callbackHttpGet(const std::string &url, completionCallback_t success = NULL, completionCallback_t failure = NULL)
+    {
+        callbackHttpGet(url, LLCore::HttpRequest::DEFAULT_POLICY_ID, success, failure);
+    }
+    static void callbackHttpPost(const std::string &url, LLCore::HttpRequest::policy_t policyId, const LLSD &postData, completionCallback_t success = NULL, completionCallback_t failure = NULL);
+    static void callbackHttpPost(const std::string &url, const LLSD &postData, completionCallback_t success = NULL, completionCallback_t failure = NULL)
+    {
+        callbackHttpPost(url, LLCore::HttpRequest::DEFAULT_POLICY_ID, postData, success, failure);
+    }
 
     /// Generic Get and post routines for HTTP via coroutines.
     /// These static methods do all required setup for the GET or POST operation.
@@ -471,8 +479,8 @@ private:
         const std::string & url, LLCore::HttpOptions::ptr_t &options,
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    static void trivialGetCoro(LLCoros::self& self, std::string url, completionCallback_t success, completionCallback_t failure);
-    static void trivialPostCoro(LLCoros::self& self, std::string url, LLSD postData, completionCallback_t success, completionCallback_t failure);
+    static void trivialGetCoro(LLCoros::self& self, std::string url, LLCore::HttpRequest::policy_t policyId, completionCallback_t success, completionCallback_t failure);
+    static void trivialPostCoro(LLCoros::self& self, std::string url, LLCore::HttpRequest::policy_t policyId, LLSD postData, completionCallback_t success, completionCallback_t failure);
 
     void checkDefaultHeaders(LLCore::HttpHeaders::ptr_t &headers);
 
-- 
cgit v1.2.3


From 08ef748cba55d5d950b224710c8592e94fcce5c7 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Thu, 25 Jun 2015 15:47:56 -0700
Subject: Added file upload interface to core HTTP utils.

---
 indra/llmessage/llcorehttputil.h | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index e98399c985..71f95dd6e4 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -43,6 +43,8 @@
 #include "llevents.h"
 #include "llcoros.h"
 #include "lleventcoro.h"
+#include "llassettype.h"
+#include "lluuid.h"
 
 ///
 /// The base llcorehttp library implements many HTTP idioms
@@ -355,6 +357,34 @@ public:
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
     }
 
+    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+        const std::string & url, std::string fileName,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+
+    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, std::string fileName,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return postFileAndYield(self, request, url, fileName,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+    }
+
+
+    LLSD HttpCoroutineAdapter::postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+        const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+
+    LLSD HttpCoroutineAdapter::postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+        const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return postFileAndYield(self, request, url, assetId, assetType,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+    }
+
+
     /// Execute a Put transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
     /// 
-- 
cgit v1.2.3


From da7b675025ef1a9b884b54340d207e7bc77d36af Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 29 Jun 2015 09:07:19 -0400
Subject: Remove extraneous class qualification from method declaration. clang
 doesn't like finding HttpCoroutineAdapter::postFileAndYield(...) inside the
 class definition for HttpCoroutineAdapter. It's much happier with plain
 postFileAndYield(...).

---
 indra/llmessage/llcorehttputil.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 71f95dd6e4..17168bd1f8 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -371,12 +371,12 @@ public:
     }
 
 
-    LLSD HttpCoroutineAdapter::postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
 
-    LLSD HttpCoroutineAdapter::postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-- 
cgit v1.2.3


From 80d17b2dd9cdd7a9445480fdb0e12774396751eb Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 29 Jun 2015 17:19:51 -0400
Subject: MAINT-4952: Use IntrusivePtr for BufferArray,HttpHeaders,HttpOptions.
 Specifically, change the ptr_t typedefs for these LLCore classes to use
 IntrusivePtr rather than directly using boost::intrusive_ptr. This allows us
 to use a simple ptr_t(raw ptr) constructor rather than having to remember to
 code ptr_t(raw ptr, false) everywhere. In fact, the latter form is now
 invalid: remove the now-extraneous 'false' constructor parameters.

---
 indra/llmessage/llcorehttputil.h | 56 ++++++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 17168bd1f8..7dd161d1cd 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -322,18 +322,18 @@ public:
     /// not be deallocated during the yield.
     LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
     LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
     LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
         return postAndYield(self, request, url, body,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
     LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
@@ -341,47 +341,47 @@ public:
         LLCore::HttpHeaders::ptr_t &headers)
     {
         return postAndYield(self, request, url, rawbody,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
     LLSD postRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
     LLSD postRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
         return postRawAndYield(self, request, url, rawbody,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
     LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, std::string fileName,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
     LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, std::string fileName,
         LLCore::HttpHeaders::ptr_t &headers)
     {
         return postFileAndYield(self, request, url, fileName,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
 
     LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
     LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpHeaders::ptr_t &headers)
     {
         return postFileAndYield(self, request, url, assetId, assetType,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false), headers);
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
 
@@ -392,8 +392,8 @@ public:
     /// not be deallocated during the yield.
     LLSD putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
     /// Execute a Get transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
@@ -402,37 +402,37 @@ public:
     /// not be deallocated during the yield.
     LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
     LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
         return getAndYield(self, request, url,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
     LLSD getRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
     LLSD getRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
         return getRawAndYield(self, request, url,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
     LLSD getJsonAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
     LLSD getJsonndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
         return getJsonAndYield(self, request, url,
-            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
@@ -444,8 +444,8 @@ public:
     /// not be deallocated during the yield.
     LLSD deleteAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
-        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions(), false),
-        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders(), false));
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
     ///
     void cancelYieldingOperation();
-- 
cgit v1.2.3


From b262ded7e0cf21314524bf702b0e4fe28a3c3060 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 1 Jul 2015 18:33:29 -0400
Subject: MAINT-5351: Remove 'self' parameter from coroutine functions.
 lleventcoro_test.cpp runs clean (as modified for new API), and all the rest
 builds clean, but the resulting viewer is as yet untested.

---
 indra/llmessage/llcorehttputil.h | 66 ++++++++++++++++++++--------------------
 1 file changed, 33 insertions(+), 33 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 7dd161d1cd..cf35177e48 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -320,67 +320,67 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postAndYield(self, request, url, body,
+        return postAndYield(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postAndYield(self, request, url, rawbody,
+        return postAndYield(request, url, rawbody,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postRawAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postRawAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postRawAndYield(self, request, url, rawbody,
+        return postRawAndYield(request, url, rawbody,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, std::string fileName,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, std::string fileName,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postFileAndYield(self, request, url, fileName,
+        return postFileAndYield(request, url, fileName,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
 
-    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postFileAndYield(self, request, url, assetId, assetType,
+        return postFileAndYield(request, url, assetId, assetType,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
@@ -390,7 +390,7 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD putAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
@@ -400,38 +400,38 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD getAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD getAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getAndYield(self, request, url,
+        return getAndYield(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    LLSD getRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD getRawAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD getRawAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getRawAndYield(self, request, url,
+        return getRawAndYield(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    LLSD getJsonAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD getJsonAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getJsonndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD getJsonndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getJsonAndYield(self, request, url,
+        return getJsonAndYield(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
@@ -442,7 +442,7 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD deleteAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD deleteAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
@@ -486,31 +486,31 @@ private:
             HttpCoroHandler::ptr_t &handler);
     void cleanState();
 
-    LLSD postAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD postAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD putAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD putAndYield_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD getAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD getAndYield_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpOptions::ptr_t &options, 
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    LLSD deleteAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD deleteAndYield_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpOptions::ptr_t &options,
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    static void trivialGetCoro(LLCoros::self& self, std::string url, LLCore::HttpRequest::policy_t policyId, completionCallback_t success, completionCallback_t failure);
-    static void trivialPostCoro(LLCoros::self& self, std::string url, LLCore::HttpRequest::policy_t policyId, LLSD postData, completionCallback_t success, completionCallback_t failure);
+    static void trivialGetCoro(std::string url, LLCore::HttpRequest::policy_t policyId, completionCallback_t success, completionCallback_t failure);
+    static void trivialPostCoro(std::string url, LLCore::HttpRequest::policy_t policyId, LLSD postData, completionCallback_t success, completionCallback_t failure);
 
     void checkDefaultHeaders(LLCore::HttpHeaders::ptr_t &headers);
 
-- 
cgit v1.2.3


From 247eb0c9c3418c10be8f2a0e3c8116758efa702f Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Tue, 7 Jul 2015 19:41:27 +0100
Subject: Backout selfles merge 738255dbbfd679d9e615baab3398e5e345bbb3c5

---
 indra/llmessage/llcorehttputil.h | 66 ++++++++++++++++++++--------------------
 1 file changed, 33 insertions(+), 33 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index cf35177e48..7dd161d1cd 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -320,67 +320,67 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postAndYield(request, url, body,
+        return postAndYield(self, request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postAndYield(request, url, rawbody,
+        return postAndYield(self, request, url, rawbody,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postRawAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postRawAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postRawAndYield(request, url, rawbody,
+        return postRawAndYield(self, request, url, rawbody,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, std::string fileName,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, std::string fileName,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postFileAndYield(request, url, fileName,
+        return postFileAndYield(self, request, url, fileName,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postFileAndYield(request, url, assetId, assetType,
+        return postFileAndYield(self, request, url, assetId, assetType,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
@@ -390,7 +390,7 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD putAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
@@ -400,38 +400,38 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD getAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getAndYield(request, url,
+        return getAndYield(self, request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    LLSD getRawAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD getRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getRawAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD getRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getRawAndYield(request, url,
+        return getRawAndYield(self, request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    LLSD getJsonAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD getJsonAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getJsonndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD getJsonndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getJsonAndYield(request, url,
+        return getJsonAndYield(self, request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
@@ -442,7 +442,7 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD deleteAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD deleteAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
@@ -486,31 +486,31 @@ private:
             HttpCoroHandler::ptr_t &handler);
     void cleanState();
 
-    LLSD postAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD postAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD putAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD putAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD getAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD getAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpOptions::ptr_t &options, 
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    LLSD deleteAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD deleteAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpOptions::ptr_t &options,
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    static void trivialGetCoro(std::string url, LLCore::HttpRequest::policy_t policyId, completionCallback_t success, completionCallback_t failure);
-    static void trivialPostCoro(std::string url, LLCore::HttpRequest::policy_t policyId, LLSD postData, completionCallback_t success, completionCallback_t failure);
+    static void trivialGetCoro(LLCoros::self& self, std::string url, LLCore::HttpRequest::policy_t policyId, completionCallback_t success, completionCallback_t failure);
+    static void trivialPostCoro(LLCoros::self& self, std::string url, LLCore::HttpRequest::policy_t policyId, LLSD postData, completionCallback_t success, completionCallback_t failure);
 
     void checkDefaultHeaders(LLCore::HttpHeaders::ptr_t &headers);
 
-- 
cgit v1.2.3


From 1138c57f9a8553903199e727912d7f1b092697e4 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 8 Jul 2015 10:01:27 -0700
Subject: Convert LLCore::HttpHeaders to use shared_ptr<> rather than an
 intrusive_ptr<> for refrence counting.

---
 indra/llmessage/llcorehttputil.h | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 7dd161d1cd..a54f94e6f0 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -112,7 +112,7 @@ LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
 									   const std::string & url,
 									   const LLSD & body,
 									   LLCore::HttpOptions * options,
-									   LLCore::HttpHeaders * headers,
+									   LLCore::HttpHeaders::ptr_t &headers,
 									   LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -125,7 +125,7 @@ inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & reque
 	LLCore::HttpHandler * handler)
 {
     return requestPostWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers.get(), handler);
+        url, body, options.get(), headers, handler);
 }
 
 inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -136,7 +136,7 @@ inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & reque
     LLCore::HttpHandler * handler)
 {
     return requestPostWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, NULL, handler);
+        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 
@@ -162,7 +162,7 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
 	const std::string & url,
 	const LLSD & body,
 	LLCore::HttpOptions * options,
-	LLCore::HttpHeaders * headers,
+	LLCore::HttpHeaders::ptr_t &headers,
 	LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -175,7 +175,7 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
 	LLCore::HttpHandler * handler)
 {
     return requestPutWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers.get(), handler);
+        url, body, options.get(), headers, handler);
 }
 
 inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -186,7 +186,7 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
     LLCore::HttpHandler * handler)
 {
     return requestPutWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, NULL, handler);
+        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 /// Issue a standard HttpRequest::requestPatch() call but using
@@ -211,7 +211,7 @@ LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest * request,
     const std::string & url,
     const LLSD & body,
     LLCore::HttpOptions * options,
-    LLCore::HttpHeaders * headers,
+    LLCore::HttpHeaders::ptr_t &headers,
     LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -224,7 +224,7 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     LLCore::HttpHandler * handler)
 {
     return requestPatchWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers.get(), handler);
+        url, body, options.get(), headers, handler);
 }
 
 inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -235,7 +235,7 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     LLCore::HttpHandler * handler)
 {
     return requestPatchWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, NULL, handler);
+        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 //=========================================================================
-- 
cgit v1.2.3


From fe5567639d7d4b6f13f66da0a1fb4bf2af295283 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 8 Jul 2015 12:09:36 -0700
Subject: Change HttpOptions::ptr_t to be shared_ptr<> rather than intrusive.

---
 indra/llmessage/llcorehttputil.h | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index a54f94e6f0..1e575e0e0c 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -111,7 +111,7 @@ LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
 									   LLCore::HttpRequest::priority_t priority,
 									   const std::string & url,
 									   const LLSD & body,
-									   LLCore::HttpOptions * options,
+                                       LLCore::HttpOptions::ptr_t &options,
 									   LLCore::HttpHeaders::ptr_t &headers,
 									   LLCore::HttpHandler * handler);
 
@@ -125,7 +125,7 @@ inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & reque
 	LLCore::HttpHandler * handler)
 {
     return requestPostWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers, handler);
+        url, body, options, headers, handler);
 }
 
 inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -136,7 +136,7 @@ inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & reque
     LLCore::HttpHandler * handler)
 {
     return requestPostWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
+        url, body, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 
@@ -161,7 +161,7 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
 	LLCore::HttpRequest::priority_t priority,
 	const std::string & url,
 	const LLSD & body,
-	LLCore::HttpOptions * options,
+	LLCore::HttpOptions::ptr_t &options,
 	LLCore::HttpHeaders::ptr_t &headers,
 	LLCore::HttpHandler * handler);
 
@@ -175,7 +175,7 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
 	LLCore::HttpHandler * handler)
 {
     return requestPutWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers, handler);
+        url, body, options, headers, handler);
 }
 
 inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -186,7 +186,7 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
     LLCore::HttpHandler * handler)
 {
     return requestPutWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
+        url, body, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 /// Issue a standard HttpRequest::requestPatch() call but using
@@ -210,7 +210,7 @@ LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest * request,
     LLCore::HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    LLCore::HttpOptions * options,
+    LLCore::HttpOptions::ptr_t &options,
     LLCore::HttpHeaders::ptr_t &headers,
     LLCore::HttpHandler * handler);
 
@@ -224,7 +224,7 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     LLCore::HttpHandler * handler)
 {
     return requestPatchWithLLSD(request.get(), policy_id, priority,
-        url, body, options.get(), headers, handler);
+        url, body, options, headers, handler);
 }
 
 inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -235,7 +235,7 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     LLCore::HttpHandler * handler)
 {
     return requestPatchWithLLSD(request.get(), policy_id, priority,
-        url, body, NULL, LLCore::HttpHeaders::ptr_t(), handler);
+        url, body, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t(), handler);
 }
 
 //=========================================================================
-- 
cgit v1.2.3


From ef3d1d642eb384fff853e227b92e20d66dbb8db7 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 8 Jul 2015 13:41:07 -0700
Subject: Replace ref parameter with value

---
 indra/llmessage/llcorehttputil.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 1e575e0e0c..4fada92666 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -111,8 +111,8 @@ LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
 									   LLCore::HttpRequest::priority_t priority,
 									   const std::string & url,
 									   const LLSD & body,
-                                       LLCore::HttpOptions::ptr_t &options,
-									   LLCore::HttpHeaders::ptr_t &headers,
+                                       LLCore::HttpOptions::ptr_t options,
+									   LLCore::HttpHeaders::ptr_t headers,
 									   LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -161,8 +161,8 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
 	LLCore::HttpRequest::priority_t priority,
 	const std::string & url,
 	const LLSD & body,
-	LLCore::HttpOptions::ptr_t &options,
-	LLCore::HttpHeaders::ptr_t &headers,
+	LLCore::HttpOptions::ptr_t options,
+	LLCore::HttpHeaders::ptr_t headers,
 	LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -210,8 +210,8 @@ LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest * request,
     LLCore::HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    LLCore::HttpOptions::ptr_t &options,
-    LLCore::HttpHeaders::ptr_t &headers,
+    LLCore::HttpOptions::ptr_t options,
+    LLCore::HttpHeaders::ptr_t headers,
     LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
-- 
cgit v1.2.3


From fed4463cb90efc29525128db21a16899b63fbcc0 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 8 Jul 2015 14:02:12 -0700
Subject: This should be semantically the same thing that was there.

---
 indra/llmessage/llcorehttputil.h | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 4fada92666..3dd13d0a0c 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -135,8 +135,11 @@ inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & reque
     const LLSD & body,
     LLCore::HttpHandler * handler)
 {
+    LLCore::HttpOptions::ptr_t options;
+    LLCore::HttpHeaders::ptr_t headers;
+
     return requestPostWithLLSD(request.get(), policy_id, priority,
-        url, body, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t(), handler);
+        url, body, options, headers, handler);
 }
 
 
@@ -185,8 +188,11 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
     const LLSD & body,
     LLCore::HttpHandler * handler)
 {
+    LLCore::HttpOptions::ptr_t options;
+    LLCore::HttpHeaders::ptr_t headers;
+
     return requestPutWithLLSD(request.get(), policy_id, priority,
-        url, body, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t(), handler);
+        url, body, options, headers, handler);
 }
 
 /// Issue a standard HttpRequest::requestPatch() call but using
@@ -234,8 +240,11 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     const LLSD & body,
     LLCore::HttpHandler * handler)
 {
+    LLCore::HttpOptions::ptr_t options;
+    LLCore::HttpHeaders::ptr_t headers;
+
     return requestPatchWithLLSD(request.get(), policy_id, priority,
-        url, body, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t(), handler);
+        url, body, options, headers, handler);
 }
 
 //=========================================================================
-- 
cgit v1.2.3


From 75b12d79e1aeeef297182e4419df7022ede485f3 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 8 Jul 2015 14:49:08 -0700
Subject: Enforcing constness of refs

---
 indra/llmessage/llcorehttputil.h | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 3dd13d0a0c..6d8f333c72 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -107,21 +107,21 @@ std::string responseToString(LLCore::HttpResponse * response);
 ///						a now-useless HttpHandler object.
 ///
 LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
-									   LLCore::HttpRequest::policy_t policy_id,
-									   LLCore::HttpRequest::priority_t priority,
-									   const std::string & url,
-									   const LLSD & body,
-                                       LLCore::HttpOptions::ptr_t options,
-									   LLCore::HttpHeaders::ptr_t headers,
-									   LLCore::HttpHandler * handler);
+    LLCore::HttpRequest::policy_t policy_id,
+    LLCore::HttpRequest::priority_t priority,
+    const std::string & url,
+    const LLSD & body,
+    const LLCore::HttpOptions::ptr_t &options,
+    const LLCore::HttpHeaders::ptr_t &headers,
+    LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
 	LLCore::HttpRequest::policy_t policy_id,
 	LLCore::HttpRequest::priority_t priority,
 	const std::string & url,
 	const LLSD & body,
-	LLCore::HttpOptions::ptr_t & options,
-	LLCore::HttpHeaders::ptr_t & headers,
+	const LLCore::HttpOptions::ptr_t & options,
+	const LLCore::HttpHeaders::ptr_t & headers,
 	LLCore::HttpHandler * handler)
 {
     return requestPostWithLLSD(request.get(), policy_id, priority,
@@ -164,8 +164,8 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
 	LLCore::HttpRequest::priority_t priority,
 	const std::string & url,
 	const LLSD & body,
-	LLCore::HttpOptions::ptr_t options,
-	LLCore::HttpHeaders::ptr_t headers,
+	const LLCore::HttpOptions::ptr_t &options,
+	const LLCore::HttpHeaders::ptr_t &headers,
 	LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -173,8 +173,8 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
 	LLCore::HttpRequest::priority_t priority,
 	const std::string & url,
 	const LLSD & body,
-	LLCore::HttpOptions::ptr_t & options,
-	LLCore::HttpHeaders::ptr_t & headers,
+	const LLCore::HttpOptions::ptr_t & options,
+	const LLCore::HttpHeaders::ptr_t & headers,
 	LLCore::HttpHandler * handler)
 {
     return requestPutWithLLSD(request.get(), policy_id, priority,
@@ -216,8 +216,8 @@ LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest * request,
     LLCore::HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    LLCore::HttpOptions::ptr_t options,
-    LLCore::HttpHeaders::ptr_t headers,
+    const LLCore::HttpOptions::ptr_t &options,
+    const LLCore::HttpHeaders::ptr_t &headers,
     LLCore::HttpHandler * handler);
 
 inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
@@ -225,8 +225,8 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     LLCore::HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    LLCore::HttpOptions::ptr_t & options,
-    LLCore::HttpHeaders::ptr_t & headers,
+    const LLCore::HttpOptions::ptr_t & options,
+    const LLCore::HttpHeaders::ptr_t & headers,
     LLCore::HttpHandler * handler)
 {
     return requestPatchWithLLSD(request.get(), policy_id, priority,
-- 
cgit v1.2.3


From efa9a0f99c17b2b937120bcad6e3d45944122ed9 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 10 Jul 2015 19:30:10 -0400
Subject: Backed out changeset bab1000e1b2d: restore 'selfless' changes

---
 indra/llmessage/llcorehttputil.h | 66 ++++++++++++++++++++--------------------
 1 file changed, 33 insertions(+), 33 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 7dd161d1cd..cf35177e48 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -320,67 +320,67 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postAndYield(self, request, url, body,
+        return postAndYield(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postAndYield(self, request, url, rawbody,
+        return postAndYield(request, url, rawbody,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postRawAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postRawAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postRawAndYield(self, request, url, rawbody,
+        return postRawAndYield(request, url, rawbody,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, std::string fileName,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, std::string fileName,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postFileAndYield(self, request, url, fileName,
+        return postFileAndYield(request, url, fileName,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
 
-    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postFileAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postFileAndYield(self, request, url, assetId, assetType,
+        return postFileAndYield(request, url, assetId, assetType,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
@@ -390,7 +390,7 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD putAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD putAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
@@ -400,38 +400,38 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD getAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD getAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getAndYield(self, request, url,
+        return getAndYield(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    LLSD getRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD getRawAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getRawAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD getRawAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getRawAndYield(self, request, url,
+        return getRawAndYield(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    LLSD getJsonAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD getJsonAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getJsonndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD getJsonndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getJsonAndYield(self, request, url,
+        return getJsonAndYield(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
@@ -442,7 +442,7 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD deleteAndYield(LLCoros::self & self, LLCore::HttpRequest::ptr_t request,
+    LLSD deleteAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
@@ -486,31 +486,31 @@ private:
             HttpCoroHandler::ptr_t &handler);
     void cleanState();
 
-    LLSD postAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD postAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndYield_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD putAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD putAndYield_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD getAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD getAndYield_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpOptions::ptr_t &options, 
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    LLSD deleteAndYield_(LLCoros::self & self, LLCore::HttpRequest::ptr_t &request,
+    LLSD deleteAndYield_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpOptions::ptr_t &options,
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    static void trivialGetCoro(LLCoros::self& self, std::string url, LLCore::HttpRequest::policy_t policyId, completionCallback_t success, completionCallback_t failure);
-    static void trivialPostCoro(LLCoros::self& self, std::string url, LLCore::HttpRequest::policy_t policyId, LLSD postData, completionCallback_t success, completionCallback_t failure);
+    static void trivialGetCoro(std::string url, LLCore::HttpRequest::policy_t policyId, completionCallback_t success, completionCallback_t failure);
+    static void trivialPostCoro(std::string url, LLCore::HttpRequest::policy_t policyId, LLSD postData, completionCallback_t success, completionCallback_t failure);
 
     void checkDefaultHeaders(LLCore::HttpHeaders::ptr_t &headers);
 
-- 
cgit v1.2.3


From 96d04a050b4eee3fc0e0728043d5aa960d06eb9e Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Thu, 30 Jul 2015 16:13:56 -0700
Subject: Added patchAndYield to httputil adapter Converted All AISv3 commands
 (except copyLibrary) to coro model.

---
 indra/llmessage/llcorehttputil.h | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 999fd5f90b..8fe2354d6b 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -456,6 +456,24 @@ public:
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
+
+    /// Execute a Post transaction on the supplied URL and yield execution of 
+    /// the coroutine until a result is available. 
+    /// 
+    /// @Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD patchAndYield(LLCore::HttpRequest::ptr_t request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
+    LLSD patchAndYield(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return patchAndYield(request, url, body,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
+    }
+
     ///
     void cancelYieldingOperation();
 
@@ -518,6 +536,11 @@ private:
         const std::string & url, LLCore::HttpOptions::ptr_t &options,
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
+    LLSD patchAndYield_(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
+        HttpCoroHandler::ptr_t &handler);
+
     static void trivialGetCoro(std::string url, LLCore::HttpRequest::policy_t policyId, completionCallback_t success, completionCallback_t failure);
     static void trivialPostCoro(std::string url, LLCore::HttpRequest::policy_t policyId, LLSD postData, completionCallback_t success, completionCallback_t failure);
 
-- 
cgit v1.2.3


From 248d61fe0eadd128c7704e37922ba7fdef35d630 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 12 Aug 2015 16:32:49 -0700
Subject: MAINT-5500: Finish converting the AIS responders to the new coroutine
 model, Cleaned up dead an unused code. MAINT-4952: Added COPY and MOVE
 methods to Core:Http adapter

---
 indra/llmessage/llcorehttputil.h | 52 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 1 deletion(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 8fe2354d6b..31a73bb900 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -457,7 +457,7 @@ public:
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
 
-    /// Execute a Post transaction on the supplied URL and yield execution of 
+    /// Execute a PATCH transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available. 
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
@@ -474,6 +474,46 @@ public:
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
+    /// Execute a COPY transaction on the supplied URL and yield execution of 
+    /// the coroutine until a result is available. 
+    /// 
+    /// @Note: The destination is passed through the HTTP pipe as a header
+    /// The header used is defined as: HTTP_OUT_HEADER_DESTINATION("Destination");
+    /// 
+    /// @Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD copyAndYield(LLCore::HttpRequest::ptr_t request,
+        const std::string & url, const std::string dest,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
+    LLSD copyAndYield(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const std::string & dest,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return copyAndYield(request, url, dest,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
+    }
+
+    /// Execute a MOVE transaction on the supplied URL and yield execution of 
+    /// the coroutine until a result is available. 
+    /// 
+    /// @Note: The destination is passed through the HTTP pipe in the headers.
+    /// The header used is defined as: HTTP_OUT_HEADER_DESTINATION("Destination");
+    /// 
+    /// @Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD moveAndYield(LLCore::HttpRequest::ptr_t request,
+        const std::string & url, const std::string dest,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
+    LLSD moveAndYield(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const std::string & dest,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return moveAndYield(request, url, dest,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
+    }
+
     ///
     void cancelYieldingOperation();
 
@@ -541,6 +581,16 @@ private:
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
+    LLSD copyAndYield_(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, 
+        LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
+        HttpCoroHandler::ptr_t &handler);
+
+    LLSD moveAndYield_(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url,
+        LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
+        HttpCoroHandler::ptr_t &handler);
+
     static void trivialGetCoro(std::string url, LLCore::HttpRequest::policy_t policyId, completionCallback_t success, completionCallback_t failure);
     static void trivialPostCoro(std::string url, LLCore::HttpRequest::policy_t policyId, LLSD postData, completionCallback_t success, completionCallback_t failure);
 
-- 
cgit v1.2.3


From 6a204b1bddc711b768d598c6ac0a16413f48d3c3 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Thu, 10 Sep 2015 16:48:01 -0700
Subject: MAINT-5575: Finished converting experience cache to singleton
 MAINT-4952: Coverted VMM to coroutines

---
 indra/llmessage/llcorehttputil.h | 69 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 68 insertions(+), 1 deletion(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 31a73bb900..6599a4f01a 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -337,6 +337,7 @@ public:
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
+
     LLSD postAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
@@ -393,6 +394,19 @@ public:
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
+    LLSD postJsonAndYield(LLCore::HttpRequest::ptr_t request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
+    LLSD postJsonAndYield(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return postJsonAndYield(request, url, body,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
+    }
+
+
 
     /// Execute a Put transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
@@ -404,11 +418,32 @@ public:
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
+    LLSD putAndYield(LLCore::HttpRequest::ptr_t request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpHeaders::ptr_t headers)
+    {
+        return putAndYield(request, url, body,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
+    }
+
+    LLSD putJsonAndYield(LLCore::HttpRequest::ptr_t request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
+    LLSD putJsonAndYield(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const LLSD & body,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return putJsonAndYield(request, url, body,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
+    }
+
     /// Execute a Get transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available.
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
+    /// 
     LLSD getAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
@@ -433,11 +468,15 @@ public:
             headers);
     }
 
+    /// These methods have the same behavior as @getAndYield() however they are 
+    /// expecting the server to return the results formatted in a JSON string. 
+    /// On a successful GET call the JSON results will be converted into LLSD 
+    /// before being returned to the caller.
     LLSD getJsonAndYield(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getJsonndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD getJsonAndYield(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
         return getJsonAndYield(request, url,
@@ -455,6 +494,29 @@ public:
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
+    LLSD deleteAndYield(LLCore::HttpRequest::ptr_t request,
+        const std::string & url, LLCore::HttpHeaders::ptr_t headers)
+    {
+        return deleteAndYield(request, url,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+            headers);
+    }
+
+    /// These methods have the same behavior as @deleteAndYield() however they are 
+    /// expecting the server to return any results formatted in a JSON string. 
+    /// On a successful DELETE call the JSON results will be converted into LLSD 
+    /// before being returned to the caller.
+    LLSD deleteJsonAndYield(LLCore::HttpRequest::ptr_t request,
+        const std::string & url,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
+    LLSD deleteJsonAndYield(LLCore::HttpRequest::ptr_t request,
+        const std::string & url, LLCore::HttpHeaders::ptr_t headers)
+    {
+        return deleteJsonAndYield(request, url,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+            headers);
+    }
 
 
     /// Execute a PATCH transaction on the supplied URL and yield execution of 
@@ -568,6 +630,11 @@ private:
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
+    LLSD putAndYield_(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const LLCore::BufferArray::ptr_t & rawbody,
+        LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
+        HttpCoroHandler::ptr_t &handler);
+
     LLSD getAndYield_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpOptions::ptr_t &options, 
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
-- 
cgit v1.2.3


From 97236a42ca08979897d5c7b0826312345754cd67 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Mon, 14 Sep 2015 11:15:23 -0700
Subject: MAINT-5507: Remove HTTPClient and related cruft.

---
 indra/llmessage/llcorehttputil.h | 1 +
 1 file changed, 1 insertion(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 6599a4f01a..94800b1a5b 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -57,6 +57,7 @@
 ///
 namespace LLCoreHttpUtil
 {
+    extern const F32 HTTP_REQUEST_EXPIRY_SECS;
 
 /// Attempt to convert a response object's contents to LLSD.
 /// It is expected that the response body will be of non-zero
-- 
cgit v1.2.3


From 75c6549fde060e974c90636685962ee373f94202 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Fri, 18 Sep 2015 11:39:22 -0700
Subject: Set consistent terminology for yield/wait -> suspend for coroutines.

---
 indra/llmessage/llcorehttputil.h | 120 +++++++++++++++++++--------------------
 1 file changed, 60 insertions(+), 60 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 94800b1a5b..9328427c34 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -330,80 +330,80 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postAndYield(request, url, body,
+        return postAndSuspend(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postAndYield(request, url, rawbody,
+        return postAndSuspend(request, url, rawbody,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postRawAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postRawAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postRawAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postRawAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postRawAndYield(request, url, rawbody,
+        return postRawAndSuspend(request, url, rawbody,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, std::string fileName,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postFileAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, std::string fileName,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postFileAndYield(request, url, fileName,
+        return postFileAndSuspend(request, url, fileName,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postFileAndYield(request, url, assetId, assetType,
+        return postFileAndSuspend(request, url, assetId, assetType,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postJsonAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD postJsonAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postJsonAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postJsonAndYield(request, url, body,
+        return postJsonAndSuspend(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
@@ -414,28 +414,28 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD putAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD putAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD putAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD putAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t headers)
     {
-        return putAndYield(request, url, body,
+        return putAndSuspend(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD putJsonAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD putJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD putJsonAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD putJsonAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return putJsonAndYield(request, url, body,
+        return putJsonAndSuspend(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
@@ -445,42 +445,42 @@ public:
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
     /// 
-    LLSD getAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD getAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD getAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getAndYield(request, url,
+        return getAndSuspend(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    LLSD getRawAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD getRawAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getRawAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD getRawAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getRawAndYield(request, url,
+        return getRawAndSuspend(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    /// These methods have the same behavior as @getAndYield() however they are 
+    /// These methods have the same behavior as @getAndSuspend() however they are 
     /// expecting the server to return the results formatted in a JSON string. 
     /// On a successful GET call the JSON results will be converted into LLSD 
     /// before being returned to the caller.
-    LLSD getJsonAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD getJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getJsonAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD getJsonAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getJsonAndYield(request, url,
+        return getJsonAndSuspend(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
@@ -491,30 +491,30 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD deleteAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD deleteAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD deleteAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD deleteAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::HttpHeaders::ptr_t headers)
     {
-        return deleteAndYield(request, url,
+        return deleteAndSuspend(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    /// These methods have the same behavior as @deleteAndYield() however they are 
+    /// These methods have the same behavior as @deleteAndSuspend() however they are 
     /// expecting the server to return any results formatted in a JSON string. 
     /// On a successful DELETE call the JSON results will be converted into LLSD 
     /// before being returned to the caller.
-    LLSD deleteJsonAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD deleteJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD deleteJsonAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD deleteJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::HttpHeaders::ptr_t headers)
     {
-        return deleteJsonAndYield(request, url,
+        return deleteJsonAndSuspend(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
@@ -525,15 +525,15 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD patchAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD patchAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD patchAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD patchAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return patchAndYield(request, url, body,
+        return patchAndSuspend(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
@@ -545,15 +545,15 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD copyAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD copyAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const std::string dest,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD copyAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD copyAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const std::string & dest,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return copyAndYield(request, url, dest,
+        return copyAndSuspend(request, url, dest,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
@@ -565,20 +565,20 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD moveAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD moveAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const std::string dest,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD moveAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD moveAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const std::string & dest,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return moveAndYield(request, url, dest,
+        return moveAndSuspend(request, url, dest,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
     ///
-    void cancelYieldingOperation();
+    void cancelSuspendedOperation();
 
     static LLCore::HttpStatus getStatusFromLLSD(const LLSD &httpResults);
 
@@ -616,45 +616,45 @@ private:
             HttpCoroHandler::ptr_t &handler);
     void cleanState();
 
-    LLSD postAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD postAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD putAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD putAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD putAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD putAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLCore::BufferArray::ptr_t & rawbody,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD getAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD getAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpOptions::ptr_t &options, 
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    LLSD deleteAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD deleteAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpOptions::ptr_t &options,
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    LLSD patchAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD patchAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD copyAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD copyAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, 
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD moveAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD moveAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
-- 
cgit v1.2.3


From 1356be0fe9e15c8205e660e491185827d74bcb07 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 7 Oct 2015 16:09:08 -0700
Subject: MAINT-5691: Browser was using deprecated outbox display type AND not
 correctly returning error body to application. LLCore:HTTP now will provide
 and LLSD translation of the message body when possible in the case of an
 error HTTP result VMM alert boxes now use type="alertmodal" rather than
 "outbox"

---
 indra/llmessage/llcorehttputil.h | 1 +
 1 file changed, 1 insertion(+)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 9328427c34..6460155134 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -282,6 +282,7 @@ public:
 protected:
     /// this method may modify the status value
     virtual LLSD handleSuccess(LLCore::HttpResponse * response, LLCore::HttpStatus &status) = 0;
+    virtual LLSD parseBody(LLCore::HttpResponse *response) = 0;
 
 private:
     void buildStatusEntry(LLCore::HttpResponse *response, LLCore::HttpStatus status, LLSD &result);
-- 
cgit v1.2.3


From bbb9d4f21b018bfffc41f790aab7b54975504027 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 14 Oct 2015 17:46:24 -0700
Subject: MAINT-5732: Change to the way event polling handles error conditions
 and cancel calls. Refactor any remaining LLCore::HTTPHandlers to use
 boost::shared_ptr Started minor refactor in the materials manager into
 coroutines (unfinished)

---
 indra/llmessage/llcorehttputil.h | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 6460155134..0ec17cda07 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -114,7 +114,7 @@ LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest * request,
     const LLSD & body,
     const LLCore::HttpOptions::ptr_t &options,
     const LLCore::HttpHeaders::ptr_t &headers,
-    LLCore::HttpHandler * handler);
+    const LLCore::HttpHandler::ptr_t &handler);
 
 inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & request,
 	LLCore::HttpRequest::policy_t policy_id,
@@ -123,7 +123,7 @@ inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & reque
 	const LLSD & body,
 	const LLCore::HttpOptions::ptr_t & options,
 	const LLCore::HttpHeaders::ptr_t & headers,
-	LLCore::HttpHandler * handler)
+    const LLCore::HttpHandler::ptr_t & handler)
 {
     return requestPostWithLLSD(request.get(), policy_id, priority,
         url, body, options, headers, handler);
@@ -134,7 +134,7 @@ inline LLCore::HttpHandle requestPostWithLLSD(LLCore::HttpRequest::ptr_t & reque
     LLCore::HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    LLCore::HttpHandler * handler)
+    const LLCore::HttpHandler::ptr_t &handler)
 {
     LLCore::HttpOptions::ptr_t options;
     LLCore::HttpHeaders::ptr_t headers;
@@ -167,7 +167,7 @@ LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest * request,
 	const LLSD & body,
 	const LLCore::HttpOptions::ptr_t &options,
 	const LLCore::HttpHeaders::ptr_t &headers,
-	LLCore::HttpHandler * handler);
+    const LLCore::HttpHandler::ptr_t &handler);
 
 inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & request,
 	LLCore::HttpRequest::policy_t policy_id,
@@ -176,7 +176,7 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
 	const LLSD & body,
 	const LLCore::HttpOptions::ptr_t & options,
 	const LLCore::HttpHeaders::ptr_t & headers,
-	LLCore::HttpHandler * handler)
+    LLCore::HttpHandler::ptr_t handler)
 {
     return requestPutWithLLSD(request.get(), policy_id, priority,
         url, body, options, headers, handler);
@@ -187,7 +187,7 @@ inline LLCore::HttpHandle requestPutWithLLSD(LLCore::HttpRequest::ptr_t & reques
     LLCore::HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    LLCore::HttpHandler * handler)
+    LLCore::HttpHandler::ptr_t handler)
 {
     LLCore::HttpOptions::ptr_t options;
     LLCore::HttpHeaders::ptr_t headers;
@@ -219,7 +219,7 @@ LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest * request,
     const LLSD & body,
     const LLCore::HttpOptions::ptr_t &options,
     const LLCore::HttpHeaders::ptr_t &headers,
-    LLCore::HttpHandler * handler);
+    const LLCore::HttpHandler::ptr_t &handler);
 
 inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & request,
     LLCore::HttpRequest::policy_t policy_id,
@@ -228,7 +228,7 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     const LLSD & body,
     const LLCore::HttpOptions::ptr_t & options,
     const LLCore::HttpHeaders::ptr_t & headers,
-    LLCore::HttpHandler * handler)
+    const LLCore::HttpHandler::ptr_t & handler)
 {
     return requestPatchWithLLSD(request.get(), policy_id, priority,
         url, body, options, headers, handler);
@@ -239,7 +239,7 @@ inline LLCore::HttpHandle requestPatchWithLLSD(LLCore::HttpRequest::ptr_t & requ
     LLCore::HttpRequest::priority_t priority,
     const std::string & url,
     const LLSD & body,
-    LLCore::HttpHandler * handler)
+    const LLCore::HttpHandler::ptr_t &handler)
 {
     LLCore::HttpOptions::ptr_t options;
     LLCore::HttpHeaders::ptr_t headers;
-- 
cgit v1.2.3


From d64ddb54caacc3d07448d4bf4a90edd3d148cc4f Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Tue, 3 Nov 2015 14:22:42 -0800
Subject: MAINT-5820: Add a success/failure result to HTTP body parse method
 and react to that rather than an "undefined" LLSD

---
 indra/llmessage/llcorehttputil.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/llmessage/llcorehttputil.h')

diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 0ec17cda07..d21f5ff45c 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -282,7 +282,7 @@ public:
 protected:
     /// this method may modify the status value
     virtual LLSD handleSuccess(LLCore::HttpResponse * response, LLCore::HttpStatus &status) = 0;
-    virtual LLSD parseBody(LLCore::HttpResponse *response) = 0;
+    virtual LLSD parseBody(LLCore::HttpResponse *response, bool &success) = 0;
 
 private:
     void buildStatusEntry(LLCore::HttpResponse *response, LLCore::HttpStatus status, LLSD &result);
-- 
cgit v1.2.3