// Token: 0x06000073 RID: 115 RVA: 0x00004148 File Offset: 0x00002348
        public static CallerRequestedCapabilities GetInstance(HttpContext requestHttpContext)
        {
            if (requestHttpContext == null)
            {
                throw new ArgumentNullException("requestHttpContext", "You must call this GetInstance method only in the cases where an HttpContext is available");
            }
            Version requestingClientVersion = null;
            Version windowsVersion          = null;
            string  text = Common.SafeGetUserAgent(requestHttpContext.Request);
            bool    canFollowRedirect = !AutodiscoverProxy.CanRedirectOutlookClient(text);
            bool    canHandleExHttpNodesInResponse = UserAgentHelper.IsWindowsClient(text);
            bool    flag = UserAgentHelper.ValidateClientSoftwareVersions(text, delegate(int major, int minor)
            {
                windowsVersion = new Version(major, minor);
                return(true);
            }, delegate(int major, int minor, int buildMajor)
            {
                requestingClientVersion = new Version(major, minor, buildMajor, 0);
                return(true);
            }) && windowsVersion != null && requestingClientVersion != null;
            bool isCallerCrossForestAvailabilityService = !string.IsNullOrWhiteSpace(text) && text.StartsWith("ASAutoDiscover/CrossForest", StringComparison.OrdinalIgnoreCase) && requestHttpContext.User != null && requestHttpContext.User.Identity is ExternalIdentity;
            bool flag2 = flag && UserAgentHelper.IsClientWin7OrGreater(text);
            bool flag3 = false;
            bool flag4 = false;

            if (flag2 && CallerRequestedCapabilities.CheckIfClientSupportsNegotiate(requestingClientVersion, out flag3))
            {
                flag4 = true;
            }
            OptInCapabilities optInCapabilities;

            if (CallerRequestedCapabilities.TryParseOptInCapabillitiesHeader(requestHttpContext, out optInCapabilities))
            {
                if ((optInCapabilities & OptInCapabilities.Negotiate) != OptInCapabilities.None)
                {
                    flag4 = true;
                }
                if ((optInCapabilities & OptInCapabilities.ExHttpInfo) != OptInCapabilities.None)
                {
                    canHandleExHttpNodesInResponse = true;
                }
            }
            return(new CallerRequestedCapabilities(canFollowRedirect, canHandleExHttpNodesInResponse, requestingClientVersion, isCallerCrossForestAvailabilityService, flag2, flag4, flag4 && flag3));
        }
        public Message LegacyAction(Message input)
        {
            Message reply = null;

            Common.SendWatsonReportOnUnhandledException(delegate
            {
                RequestData requestData = null;
                object obj = null;
                HttpContext httpContext = HttpContext.Current;
                if (input.Properties.TryGetValue("RequestData", out obj))
                {
                    requestData = (RequestData)obj;
                }
                else
                {
                    bool useClientCertificateAuthentication = Common.CheckClientCertificate(httpContext.Request);
                    requestData = new RequestData(null, useClientCertificateAuthentication, CallerRequestedCapabilities.GetInstance(httpContext));
                    input.Properties["RequestData"]  = requestData;
                    input.Properties["ParseSuccess"] = false;
                }
                string userAgent = Common.SafeGetUserAgent(httpContext.Request);
                ProxyAddress proxyAddress;
                if (VariantConfiguration.InvariantNoFlightingSnapshot.Autodiscover.RedirectOutlookClient.Enabled && AutodiscoverProxy.CanRedirectOutlookClient(userAgent) && !string.IsNullOrEmpty(requestData.EMailAddress) && SmtpProxyAddress.TryDeencapsulate(requestData.EMailAddress, out proxyAddress))
                {
                    requestData.EMailAddress = proxyAddress.AddressString;
                }
                LegacyBodyWriter bodyWriter;
                RequestDetailsLoggerBase <RequestDetailsLogger> .Current.TrackLatency(ServiceLatencyMetadata.CoreExecutionLatency, delegate()
                {
                    if (!HttpContext.Current.Request.IsAuthenticated)
                    {
                        requestData.Clear();
                        input.Properties["ParseSuccess"] = false;
                        bodyWriter = new LegacyBodyWriter(input, HttpContext.Current);
                        reply      = Message.CreateMessage(MessageVersion.None, "*", bodyWriter);
                        HttpResponseMessageProperty httpResponseMessageProperty = new HttpResponseMessageProperty();
                        httpResponseMessageProperty.StatusCode = HttpStatusCode.Unauthorized;
                        reply.Properties.Add(HttpResponseMessageProperty.Name, httpResponseMessageProperty);
                        return;
                    }
                    bodyWriter = new LegacyBodyWriter(input, HttpContext.Current);
                    reply      = Message.CreateMessage(MessageVersion.None, "*", bodyWriter);
                });
            });
            return(reply);
        }