Whitespace fixes.

1 files changed, 61 insertions, 61 deletions

diff --git a/src/DotNetOpenAuth.Core/Messaging/MessagingUtilities.cs b/src/DotNetOpenAuth.Core/Messaging/MessagingUtilities.cs
index cb253b4..bbe28ab 100644
--- a/src/DotNetOpenAuth.Core/Messaging/MessagingUtilities.cs
+++ b/src/DotNetOpenAuth.Core/Messaging/MessagingUtilities.cs
@@ -370,63 +370,63 @@ namespace DotNetOpenAuth.Messaging {
 			}
 
 			return result == 0;
-		}

-

-		/// <summary>

-		/// Gets the public facing URL for the given incoming HTTP request.

-		/// </summary>

-		/// <param name="request">The incoming request.  Cannot be <c>null</c>.</param>

-		/// <param name="serverVariables">The server variables to consider part of the request.  Cannot be <c>null</c>.</param>

-		/// <returns>

-		/// The URI that the outside world used to create this request.

-		/// </returns>

-		/// <remarks>

-		/// Although the <paramref name="serverVariables"/> value can be obtained from

-		/// <see cref="HttpRequest.ServerVariables"/>, it's useful to be able to pass them

-		/// in so we can simulate injected values from our unit tests since the actual property

-		/// is a read-only kind of <see cref="NameValueCollection"/>.

-		/// </remarks>

-		public static Uri GetPublicFacingUrl(this HttpRequestBase request, NameValueCollection serverVariables) {

-			Requires.NotNull(request, "request");

-			Requires.NotNull(serverVariables, "serverVariables");

-

-			// Due to URL rewriting, cloud computing (i.e. Azure)

-			// and web farms, etc., we have to be VERY careful about what

-			// we consider the incoming URL.  We want to see the URL as it would

-			// appear on the public-facing side of the hosting web site.

-			// HttpRequest.Url gives us the internal URL in a cloud environment,

-			// So we use a variable that (at least from what I can tell) gives us

-			// the public URL:

-			if (serverVariables["HTTP_HOST"] != null) {

-				ErrorUtilities.VerifySupported(request.Url.Scheme == Uri.UriSchemeHttps || request.Url.Scheme == Uri.UriSchemeHttp, "Only HTTP and HTTPS are supported protocols.");

-				string scheme = serverVariables["HTTP_X_FORWARDED_PROTO"] ?? request.Url.Scheme;

-				Uri hostAndPort = new Uri(scheme + Uri.SchemeDelimiter + serverVariables["HTTP_HOST"]);

-				UriBuilder publicRequestUri = new UriBuilder(request.Url);

-				publicRequestUri.Scheme = scheme;

-				publicRequestUri.Host = hostAndPort.Host;

-				publicRequestUri.Port = hostAndPort.Port; // CC missing Uri.Port contract that's on UriBuilder.Port

-				return publicRequestUri.Uri;

-			} else {

-				// Failover to the method that works for non-web farm enviroments.

-				// We use Request.Url for the full path to the server, and modify it

-				// with Request.RawUrl to capture both the cookieless session "directory" if it exists

-				// and the original path in case URL rewriting is going on.  We don't want to be

-				// fooled by URL rewriting because we're comparing the actual URL with what's in

-				// the return_to parameter in some cases.

-				// Response.ApplyAppPathModifier(builder.Path) would have worked for the cookieless

-				// session, but not the URL rewriting problem.

-				return new Uri(request.Url, request.RawUrl);

-			}

-		}

-

-		/// <summary>

-		/// Gets the public facing URL for the given incoming HTTP request.

-		/// </summary>

-		/// <param name="request">The incoming request.  Cannot be <c>null</c>.  Server variables are read from this request.</param>

-		/// <returns>The URI that the outside world used to create this request.</returns>

-		public static Uri GetPublicFacingUrl(this HttpRequestBase request) {

-			Requires.NotNull(request, "request");

-			return GetPublicFacingUrl(request, request.ServerVariables);

+		}
+
+		/// <summary>
+		/// Gets the public facing URL for the given incoming HTTP request.
+		/// </summary>
+		/// <param name="request">The incoming request.  Cannot be <c>null</c>.</param>
+		/// <param name="serverVariables">The server variables to consider part of the request.  Cannot be <c>null</c>.</param>
+		/// <returns>
+		/// The URI that the outside world used to create this request.
+		/// </returns>
+		/// <remarks>
+		/// Although the <paramref name="serverVariables"/> value can be obtained from
+		/// <see cref="HttpRequest.ServerVariables"/>, it's useful to be able to pass them
+		/// in so we can simulate injected values from our unit tests since the actual property
+		/// is a read-only kind of <see cref="NameValueCollection"/>.
+		/// </remarks>
+		public static Uri GetPublicFacingUrl(this HttpRequestBase request, NameValueCollection serverVariables) {
+			Requires.NotNull(request, "request");
+			Requires.NotNull(serverVariables, "serverVariables");
+
+			// Due to URL rewriting, cloud computing (i.e. Azure)
+			// and web farms, etc., we have to be VERY careful about what
+			// we consider the incoming URL.  We want to see the URL as it would
+			// appear on the public-facing side of the hosting web site.
+			// HttpRequest.Url gives us the internal URL in a cloud environment,
+			// So we use a variable that (at least from what I can tell) gives us
+			// the public URL:
+			if (serverVariables["HTTP_HOST"] != null) {
+				ErrorUtilities.VerifySupported(request.Url.Scheme == Uri.UriSchemeHttps || request.Url.Scheme == Uri.UriSchemeHttp, "Only HTTP and HTTPS are supported protocols.");
+				string scheme = serverVariables["HTTP_X_FORWARDED_PROTO"] ?? request.Url.Scheme;
+				Uri hostAndPort = new Uri(scheme + Uri.SchemeDelimiter + serverVariables["HTTP_HOST"]);
+				UriBuilder publicRequestUri = new UriBuilder(request.Url);
+				publicRequestUri.Scheme = scheme;
+				publicRequestUri.Host = hostAndPort.Host;
+				publicRequestUri.Port = hostAndPort.Port; // CC missing Uri.Port contract that's on UriBuilder.Port
+				return publicRequestUri.Uri;
+			} else {
+				// Failover to the method that works for non-web farm enviroments.
+				// We use Request.Url for the full path to the server, and modify it
+				// with Request.RawUrl to capture both the cookieless session "directory" if it exists
+				// and the original path in case URL rewriting is going on.  We don't want to be
+				// fooled by URL rewriting because we're comparing the actual URL with what's in
+				// the return_to parameter in some cases.
+				// Response.ApplyAppPathModifier(builder.Path) would have worked for the cookieless
+				// session, but not the URL rewriting problem.
+				return new Uri(request.Url, request.RawUrl);
+			}
+		}
+
+		/// <summary>
+		/// Gets the public facing URL for the given incoming HTTP request.
+		/// </summary>
+		/// <param name="request">The incoming request.  Cannot be <c>null</c>.  Server variables are read from this request.</param>
+		/// <returns>The URI that the outside world used to create this request.</returns>
+		public static Uri GetPublicFacingUrl(this HttpRequestBase request) {
+			Requires.NotNull(request, "request");
+			return GetPublicFacingUrl(request, request.ServerVariables);
 		}
 
 		/// <summary>
@@ -1561,9 +1561,9 @@ namespace DotNetOpenAuth.Messaging {
 				return HttpDeliveryMethods.DeleteRequest;
 			} else if (httpVerb == "HEAD") {
 				return HttpDeliveryMethods.HeadRequest;
-			} else if (httpVerb == "PATCH") {

+			} else if (httpVerb == "PATCH") {
 				return HttpDeliveryMethods.PatchRequest;
-			} else if (httpVerb == "OPTIONS") {

+			} else if (httpVerb == "OPTIONS") {
 				return HttpDeliveryMethods.OptionsRequest;
 			} else {
 				throw ErrorUtilities.ThrowArgumentNamed("httpVerb", MessagingStrings.UnsupportedHttpVerb, httpVerb);
@@ -1586,9 +1586,9 @@ namespace DotNetOpenAuth.Messaging {
 				return "DELETE";
 			} else if ((httpMethod & HttpDeliveryMethods.HttpVerbMask) == HttpDeliveryMethods.HeadRequest) {
 				return "HEAD";
-			} else if ((httpMethod & HttpDeliveryMethods.HttpVerbMask) == HttpDeliveryMethods.PatchRequest) {

+			} else if ((httpMethod & HttpDeliveryMethods.HttpVerbMask) == HttpDeliveryMethods.PatchRequest) {
 				return "PATCH";
-			} else if ((httpMethod & HttpDeliveryMethods.HttpVerbMask) == HttpDeliveryMethods.OptionsRequest) {

+			} else if ((httpMethod & HttpDeliveryMethods.HttpVerbMask) == HttpDeliveryMethods.OptionsRequest) {
 				return "OPTIONS";
 			} else if ((httpMethod & HttpDeliveryMethods.AuthorizationHeaderRequest) != 0) {
 				return "GET"; // if AuthorizationHeaderRequest is specified without an explicit HTTP verb, assume GET.