// _id is used by OutputCacheProviders

private Guid _cachedVaryId;

internal readonly string[] _contentEncodings;

internal readonly string[] _headers;

internal readonly string[] _params;

internal readonly string _varyByCustom;

internal readonly bool _varyByAllParams;

internal Guid CachedVaryId { get { return _cachedVaryId; } }

internal CachedVary(string[] contentEncodings, string[] headers, string[] parameters, bool varyByAllParams, string varyByCustom) {

_contentEncodings = contentEncodings;

_headers = headers;

_params = parameters;

_varyByAllParams = varyByAllParams;

_varyByCustom = varyByCustom;

_cachedVaryId = Guid.NewGuid();

}

public override bool Equals(Object obj) {

CachedVary cv = obj as CachedVary;

if (cv == null) {

return false;

}

return _varyByAllParams == cv._varyByAllParams

&& _varyByCustom == cv._varyByCustom

&& StringUtil.StringArrayEquals(_contentEncodings, cv._contentEncodings)

&& StringUtil.StringArrayEquals(_headers, cv._headers)

&& StringUtil.StringArrayEquals(_params, cv._params);

}

public override int GetHashCode() {

HashCodeCombiner hashCodeCombiner = new HashCodeCombiner();

hashCodeCombiner.AddObject(_varyByAllParams);

// Cast _varyByCustom to an object, since the HashCodeCombiner.AddObject(string)

// overload uses StringUtil.GetStringHashCode(). We want to use String.GetHashCode()

// in this method, since we do not require a stable hash code across architectures.

hashCodeCombiner.AddObject((object)_varyByCustom);

hashCodeCombiner.AddArray(_contentEncodings);

hashCodeCombiner.AddArray(_headers);

hashCodeCombiner.AddArray(_params);

return hashCodeCombiner.CombinedHash32;

}

/*

internal Guid _cachedVaryId;

internal readonly HttpRawResponse _rawResponse;

internal readonly HttpCachePolicySettings _settings;

internal readonly String _kernelCacheUrl;

internal CachedRawResponse(

HttpRawResponse rawResponse,

HttpCachePolicySettings settings,

String kernelCacheUrl,

Guid cachedVaryId) {

_rawResponse = rawResponse;

_settings = settings;

_kernelCacheUrl = kernelCacheUrl;

_cachedVaryId = cachedVaryId;

}

const int MAX_POST_KEY_LENGTH = 15000;

const string NULL_VARYBY_VALUE = "+n+";

const string ERROR_VARYBY_VALUE = "+e+";

internal const string TAG_OUTPUTCACHE = "OutputCache";

const string OUTPUTCACHE_KEYPREFIX_POST = CacheInternal.PrefixOutputCache + "1";

const string OUTPUTCACHE_KEYPREFIX_GET = CacheInternal.PrefixOutputCache + "2";

const string IDENTITY = "identity";

const string ASTERISK = "*";

static internal readonly char[] s_fieldSeparators;

string _key;

bool _recordedCacheMiss;

static OutputCacheModule() {

s_fieldSeparators = new char[] {',', ' '};

}

internal OutputCacheModule() {

}

internal static string CreateOutputCachedItemKey(

string path,

HttpVerb verb,

HttpContext context,

CachedVary cachedVary) {

StringBuilder sb;

int i, j, n;

string name, value;

string[] a;

byte[] buf;

HttpRequest request;

NameValueCollection col;

int contentLength;

bool getAllParams;

if (verb == HttpVerb.POST) {

sb = new StringBuilder(OUTPUTCACHE_KEYPREFIX_POST, path.Length + OUTPUTCACHE_KEYPREFIX_POST.Length);

}

else {

sb = new StringBuilder(OUTPUTCACHE_KEYPREFIX_GET, path.Length + OUTPUTCACHE_KEYPREFIX_GET.Length);

}

sb.Append(CultureInfo.InvariantCulture.TextInfo.ToLower(path));

/* key for cached vary item has additional information */

if (cachedVary != null) {

request = context.Request;

/* params part */

for (j = 0; j <= 2; j++) {

a = null;

col = null;

getAllParams = false;

switch (j) {

case 0:

sb.Append("H");

a = cachedVary._headers;

if (a != null) {

col = request.GetServerVarsWithoutDemand();

}

break;

case 1:

Debug.Assert(cachedVary._params == null || !cachedVary._varyByAllParams, "cachedVary._params == null || !cachedVary._varyByAllParams");

sb.Append("Q");

a = cachedVary._params;

if (request.HasQueryString && (a != null || cachedVary._varyByAllParams)) {

col = request.QueryString;

getAllParams = cachedVary._varyByAllParams;

}

break;

case 2:

default:

Debug.Assert(cachedVary._params == null || !cachedVary._varyByAllParams, "cachedVary._params == null || !cachedVary._varyByAllParams");

sb.Append("F");

if (verb == HttpVerb.POST) {

a = cachedVary._params;

if (request.HasForm && (a != null || cachedVary._varyByAllParams)) {

col = request.Form;

getAllParams = cachedVary._varyByAllParams;

}

}

break;

}

Debug.Assert(a == null || !getAllParams, "a == null || !getAllParams");

/* handle all params case (VaryByParams[*] = true) */

if (getAllParams && col.Count > 0) {

a = col.AllKeys;

for (i = a.Length - 1; i >= 0; i--) {

if (a[i] != null)

a[i] = CultureInfo.InvariantCulture.TextInfo.ToLower(a[i]);

}

Array.Sort(a, InvariantComparer.Default);

}

if (a != null) {

for (i = 0, n = a.Length; i < n; i++) {

name = a[i];

if (col == null) {

value = NULL_VARYBY_VALUE;

}

else {

value = col[name];

if (value == null) {

value = NULL_VARYBY_VALUE;

}

}

sb.Append("N");

sb.Append(name);

sb.Append("V");

sb.Append(value);

}

}

}

/* custom string part */

sb.Append("C");

if (cachedVary._varyByCustom != null) {

sb.Append("N");

sb.Append(cachedVary._varyByCustom);

sb.Append("V");

try {

value = context.ApplicationInstance.GetVaryByCustomString(

context, cachedVary._varyByCustom);

if (value == null) {

value = NULL_VARYBY_VALUE;

}

}

catch (Exception e) {

value = ERROR_VARYBY_VALUE;

HttpApplicationFactory.RaiseError(e);

}

sb.Append(value);

}

/*

sb.Append("D");

if ( verb == HttpVerb.POST &&

cachedVary._varyByAllParams &&

request.Form.Count == 0) {

contentLength = request.ContentLength;

if (contentLength > MAX_POST_KEY_LENGTH || contentLength < 0) {

return null;

}

if (contentLength > 0) {

buf = ((HttpInputStream)request.InputStream).GetAsByteArray();

if (buf == null) {

return null;

}

// Use SHA256 to generate a collision-free hash of the input data

value = Convert.ToBase64String(CryptoUtil.ComputeSHA256Hash(buf));

sb.Append(value);

}

}

/*

sb.Append("E");

string[] contentEncodings = cachedVary._contentEncodings;

if (contentEncodings != null) {

string coding = context.Response.GetHttpHeaderContentEncoding();

if (coding != null) {

for (int k = 0; k < contentEncodings.Length; k++) {

if (contentEncodings[k] == coding) {

sb.Append(coding);

break;

}

}

}

}

// The key must end in "E", or the VaryByContentEncoding feature will break. Unfortunately,

// there was no good way to encapsulate the logic within this routine. See the code in

// OnEnter where we append the result of GetAcceptableEncoding to the key.

}

return sb.ToString();

}

/*

string CreateOutputCachedItemKey(HttpContext context, CachedVary cachedVary) {

return CreateOutputCachedItemKey(context.Request.Path, context.Request.HttpVerb, context, cachedVary);

}

/*

static int GetAcceptableEncoding(string[] contentEncodings, int startIndex, string acceptEncoding) {

// The format of Accept-Encoding is ( 1#( codings [ ";" "q" "=" qvalue ] ) | "*" )

if (String.IsNullOrEmpty(acceptEncoding)) {

return -1; // use "identity"

}

// is there only one token?

int tokenEnd = acceptEncoding.IndexOf(',');

if (tokenEnd == -1) {

string acceptEncodingWithoutWeight = acceptEncoding;

// WOS 1984913: is there a weight?

tokenEnd = acceptEncoding.IndexOf(';');

if (tokenEnd > -1) {

// remove weight

int space = acceptEncoding.IndexOf(' ');

if (space > -1 && space < tokenEnd) {

tokenEnd = space;

}

acceptEncodingWithoutWeight = acceptEncoding.Substring(0, tokenEnd);

if (ParseWeight(acceptEncoding, tokenEnd) == 0) {

// WOS 1985352 & WOS 1985353: weight is 0, use "identity" only if it is acceptable

bool identityIsAcceptable = acceptEncodingWithoutWeight != IDENTITY && acceptEncodingWithoutWeight != ASTERISK;

return (identityIsAcceptable) ? -1 : -2;

}

}

// WOS 1985353: is this the special "*" symbol?

if (acceptEncodingWithoutWeight == ASTERISK) {

// just return the index of the first entry in the list, since it is acceptable

return 0;

}

for (int i = startIndex; i < contentEncodings.Length; i++) {

if (StringUtil.EqualsIgnoreCase(contentEncodings[i], acceptEncodingWithoutWeight)) {

return i; // found

}

}

return -1; // not found, use "identity"

}

// there are multiple tokens

int bestCodingIndex = -1;

double bestCodingWeight = 0;

for (int i = startIndex; i < contentEncodings.Length; i++) {

string coding = contentEncodings[i];

// get weight of current coding

double weight = GetAcceptableEncodingHelper(coding, acceptEncoding);

// if it is 1, use it

if (weight == 1) {

return i;

}

// if it is the best so far, remember it

if (weight > bestCodingWeight) {

bestCodingIndex = i;

bestCodingWeight = weight;

}

}

// WOS 1985352: use "identity" only if it is acceptable

if (bestCodingIndex == -1 && !IsIdentityAcceptable(acceptEncoding)) {

bestCodingIndex = -2;

}

return bestCodingIndex; // coding index with highest weight, possibly -1 or -2

}

// Get the weight of the specified coding from the Accept-Encoding header.

// 1 means use this coding. 0 means don't use this coding. A number between

// 1 and 0 must be compared with other codings. -1 means the coding was not found

static double GetAcceptableEncodingHelper(string coding, string acceptEncoding) {

double weight = -1;

int startSearchIndex = 0;

int codingLength = coding.Length;

int acceptEncodingLength = acceptEncoding.Length;

int maxSearchIndex = acceptEncodingLength - codingLength;

while (startSearchIndex < maxSearchIndex) {

int indexStart = acceptEncoding.IndexOf(coding, startSearchIndex, StringComparison.OrdinalIgnoreCase);

if (indexStart == -1) {

break; // not found

}

// if index is in middle of string, previous char should be ' ' or ','

if (indexStart != 0) {

char previousChar = acceptEncoding[indexStart-1];

if (previousChar != ' ' && previousChar != ',') {

startSearchIndex = indexStart + 1;

continue; // move index forward and continue searching

}

}

// the match starts on a token boundary, but it must also end

// on a token boundary ...

int indexNextChar = indexStart + codingLength;

char nextChar = '\0';

if (indexNextChar < acceptEncodingLength) {

nextChar = acceptEncoding[indexNextChar];

while (nextChar == ' ' && ++indexNextChar < acceptEncodingLength) {

nextChar = acceptEncoding[indexNextChar];

}

if (nextChar != ' ' && nextChar != ',' && nextChar != ';') {

startSearchIndex = indexStart + 1;

continue; // move index forward and continue searching

}

}

weight = (nextChar == ';') ? ParseWeight(acceptEncoding, indexNextChar) : 1;

break; // found

}

return weight;

}

// Gets the weight of the encoding beginning at startIndex.

// If Accept-Encoding header is formatted incorrectly, return 1 to short-circuit search.

static double ParseWeight(string acceptEncoding, int startIndex) {

double weight = 1;

int tokenEnd = acceptEncoding.IndexOf(',', startIndex);

if (tokenEnd == -1) {

tokenEnd = acceptEncoding.Length;

}

int qIndex = acceptEncoding.IndexOf('q', startIndex);

if (qIndex > -1 && qIndex < tokenEnd) {

int equalsIndex = acceptEncoding.IndexOf('=', qIndex);

if (equalsIndex > -1 && equalsIndex < tokenEnd) {

string s = acceptEncoding.Substring(equalsIndex+1, tokenEnd - (equalsIndex + 1));

double d;

if (Double.TryParse(s, NumberStyles.Float & ~NumberStyles.AllowLeadingSign & ~NumberStyles.AllowExponent, CultureInfo.InvariantCulture, out d)) {

weight = (d >= 0 && d <= 1) ? d : 1; // if format is invalid, short-circut search by returning weight of 1

}

}

}

return weight;

}

static bool IsIdentityAcceptable(string acceptEncoding) {

bool result = true;

double identityWeight = GetAcceptableEncodingHelper(IDENTITY, acceptEncoding);

if (identityWeight == 0

|| (identityWeight <= 0 && GetAcceptableEncodingHelper(ASTERISK, acceptEncoding) == 0)) {

result = false;

}

return result;

}

static bool IsAcceptableEncoding(string contentEncoding, string acceptEncoding) {

if (String.IsNullOrEmpty(contentEncoding)) {

// if Content-Encoding is not set treat it as the identity

contentEncoding = IDENTITY;

}

if (String.IsNullOrEmpty(acceptEncoding)) {

// only the identity is acceptable if Accept-Encoding is not set

return (contentEncoding == IDENTITY);

}

double weight = GetAcceptableEncodingHelper(contentEncoding, acceptEncoding);

if (weight == 0

|| (weight <= 0 && GetAcceptableEncodingHelper(ASTERISK, acceptEncoding) == 0)) {

return false;

}

return true;

}

/*

void RecordCacheMiss() {

if (!_recordedCacheMiss) {

PerfCounters.IncrementCounter(AppPerfCounter.OUTPUT_CACHE_RATIO_BASE);

PerfCounters.IncrementCounter(AppPerfCounter.OUTPUT_CACHE_MISSES);

_recordedCacheMiss = true;

}

}

/// <devdoc>

/// <para>Initializes the output cache for an application.</para>

/// </devdoc>

void IHttpModule.Init(HttpApplication app) {

OutputCacheSection cacheConfig = RuntimeConfig.GetAppConfig().OutputCache;

if (cacheConfig.EnableOutputCache) {

app.ResolveRequestCache += new EventHandler(this.OnEnter);

app.UpdateRequestCache += new EventHandler(this.OnLeave);

}

}

/// <devdoc>

/// <para>Disposes of items from the output cache.</para>

/// </devdoc>

void IHttpModule.Dispose() {

}

/*

/// <devdoc>

/// <para>Raises the <see langword='Enter'/>

/// event, which searches the output cache for an item to satisfy the HTTP request. </para>

/// </devdoc>

internal void OnEnter(Object source, EventArgs eventArgs) {

Debug.Trace("OutputCacheModuleEnter", "Beginning OutputCacheModule::Enter");

_key = null;

_recordedCacheMiss = false;

if (!OutputCache.InUse) {

Debug.Trace("OutputCacheModuleEnter", "Miss, no entries in output Cache" +

"\nReturning from OutputCacheModule::Enter");

return;

}

HttpApplication app;

HttpContext context;

string key;

HttpRequest request;

HttpResponse response;

Object item;

CachedRawResponse cachedRawResponse;

HttpCachePolicySettings settings;

int i, n;

bool sendBody;

HttpValidationStatus validationStatus, validationStatusFinal;

ValidationCallbackInfo callbackInfo;

string ifModifiedSinceHeader;

DateTime utcIfModifiedSince;

string etag;

string[] etags;

int send304;

string cacheControl;

string[] cacheDirectives = null;

string pragma;

string[] pragmaDirectives = null;

string directive;

int maxage;

int minfresh;

int age;

int fresh;

bool hasValidationPolicy;

CachedVary cachedVary;

HttpRawResponse rawResponse;

CachedPathData cachedPathData;

app = (HttpApplication)source;

context = app.Context;

cachedPathData = context.GetFilePathData();

request = context.Request;

response = context.Response;

/*

switch (request.HttpVerb) {

case HttpVerb.HEAD:

case HttpVerb.GET:

case HttpVerb.POST:

break;

default:

Debug.Trace("OutputCacheModuleEnter", "Miss, Http method not GET, POST, or HEAD" +

"\nReturning from OutputCacheModule::Enter");

return;

}

/*

_key = key = CreateOutputCachedItemKey(context, null);

Debug.Assert(_key != null, "_key != null");

/*

item = OutputCache.Get(key);

if (item == null) {

Debug.Trace("OutputCacheModuleEnter", "Miss, item not found.\n\tkey=" + key +

"\nReturning from OutputCacheModule::Enter");

return;

}

// 'item' may be one of the following:

// - a CachedVary object (if the object varies by something)

// - a "no vary" CachedRawResponse object (i.e. it doesn't vary on anything)

// Let's assume it's a CacheVary and see what happens.

cachedVary = item as CachedVary;

// If we have one, create a new cache key for it (this is a must)

if (cachedVary != null) {

/*

key = CreateOutputCachedItemKey(context, cachedVary);

if (key == null) {

Debug.Trace("OutputCacheModuleEnter", "Miss, key could not be created for vary-by item." +

"\nReturning from OutputCacheModule::Enter");

return;

}

if (cachedVary._contentEncodings == null) {

// With the new key, look up the in-memory key.

// At this point, we've exhausted the lookups in memory for this item.

item = OutputCache.Get(key);

}

else {

#if DBG

Debug.Assert(key[key.Length-1] == 'E', "key[key.Length-1] == 'E'");

#endif

item = null;

bool identityIsAcceptable = true;

string acceptEncoding = context.WorkerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderAcceptEncoding);

if (acceptEncoding != null) {

string[] contentEncodings = cachedVary._contentEncodings;

int startIndex = 0;

bool done = false;

while (!done) {

done = true;

int index = GetAcceptableEncoding(contentEncodings, startIndex, acceptEncoding);

if (index > -1) {

#if DBG

Debug.Trace("OutputCacheModuleEnter", "VaryByContentEncoding key=" + key + contentEncodings[index]);

#endif

identityIsAcceptable = false; // the client Accept-Encoding header contains an encoding that's in the VaryByContentEncoding list

item = OutputCache.Get(key + contentEncodings[index]);

if (item == null) {

startIndex = index+1;

if (startIndex < contentEncodings.Length) {

done = false;

}

}

}

else if (index == -2) {

// the identity has a weight of 0 and is not acceptable

identityIsAcceptable = false;

}

}

}

// the identity should not be used if the client Accept-Encoding contains an entry in the VaryByContentEncoding list or "identity" is not acceptable

if (item == null && identityIsAcceptable) {

#if DBG

Debug.Trace("OutputCacheModuleEnter", "VaryByContentEncoding key=" + key);

#endif

item = OutputCache.Get(key);

}

}

Debug.Assert(item == null || item is CachedRawResponse, "item == null || item is CachedRawResponse");

if (item == null || ((CachedRawResponse)item)._cachedVaryId != cachedVary.CachedVaryId) {

#if DBG

if (item == null) {

Debug.Trace("OutputCacheModuleEnter", "Miss, cVary found, cRawResponse not found.\n\t\tkey=" + key +

"\nReturning from OutputCacheModule::Enter");

}

else {

string msg = "Miss, _cachedVaryId=" + ((CachedRawResponse)item)._cachedVaryId.ToString() + ", cVary.CachedVaryId=" + cachedVary.CachedVaryId.ToString();

Debug.Trace("OutputCacheModuleEnter", msg + key +

"\nReturning from OutputCacheModule::Enter");

}

#endif

if (item != null) {

// explicitly remove entry because _cachedVaryId does not match

OutputCache.Remove(key, context);

}

return;

}

}

// From this point on, we have an entry to work with.

Debug.Assert(item is CachedRawResponse, "item is CachedRawResponse");

cachedRawResponse = (CachedRawResponse) item;

settings = cachedRawResponse._settings;

if (cachedVary == null && !settings.IgnoreParams) {

/*

if (request.HttpVerb == HttpVerb.POST) {

Debug.Trace("OutputCacheModuleEnter", "Output cache item found but method is POST and no VaryByParam specified." +

"\n\tkey=" + key +

"\nReturning from OutputCacheModule::Enter");

RecordCacheMiss();

return;

}

if (request.HasQueryString) {

Debug.Trace("OutputCacheModuleEnter", "Output cache item found but contains a querystring and no VaryByParam specified." +

"\n\tkey=" + key +

"\nReturning from OutputCacheModule::Enter");

RecordCacheMiss();

return;

}

}

if (settings.IgnoreRangeRequests) {

string rangeHeader = request.Headers["Range"];

if (StringUtil.StringStartsWithIgnoreCase(rangeHeader, "bytes")) {

Debug.Trace("OutputCacheModuleEnter", "Output cache item found but this is a Range request and IgnoreRangeRequests is true." +

"\n\tkey=" + key +

"\nReturning from OutputCacheModule::Enter");

// Don't record this as a cache miss. The response for a range request is not cached, and so

// we don't want to pollute the cache hit/miss ratio.

return;

}

}

hasValidationPolicy = settings.HasValidationPolicy();

/*

if (!hasValidationPolicy) {

cacheControl = request.Headers["Cache-Control"];

if (cacheControl != null) {

cacheDirectives = cacheControl.Split(s_fieldSeparators);

for (i = 0; i < cacheDirectives.Length; i++) {

directive = cacheDirectives[i];

if (directive == "no-cache" || directive == "no-store") {

Debug.Trace("OutputCacheModuleEnter",

"Skipping lookup because of Cache-Control: no-cache or no-store directive." +

"\nReturning from OutputCacheModule::Enter");

RecordCacheMiss();

return;

}

if (StringUtil.StringStartsWith(directive, "max-age=")) {

try {

maxage = Convert.ToInt32(directive.Substring(8), CultureInfo.InvariantCulture);

}

catch {

maxage = -1;

}

if (maxage >= 0) {

age = (int) ((context.UtcTimestamp.Ticks - settings.UtcTimestampCreated.Ticks) / TimeSpan.TicksPerSecond);

if (age >= maxage) {

Debug.Trace("OutputCacheModuleEnter",

"Not returning found item due to Cache-Control: max-age directive." +

"\nReturning from OutputCacheModule::Enter");

RecordCacheMiss();

return;

}

}

}

else if (StringUtil.StringStartsWith(directive, "min-fresh=")) {

try {

minfresh = Convert.ToInt32(directive.Substring(10), CultureInfo.InvariantCulture);

}

catch {

minfresh = -1;

}

if (minfresh >= 0 && settings.IsExpiresSet && !settings.SlidingExpiration) {

fresh = (int) ((settings.UtcExpires.Ticks - context.UtcTimestamp.Ticks) / TimeSpan.TicksPerSecond);

if (fresh < minfresh) {

Debug.Trace("OutputCacheModuleEnter",

"Not returning found item due to Cache-Control: min-fresh directive." +

"\nReturning from OutputCacheModule::Enter");

RecordCacheMiss();

return;

}

}

}

}

}

pragma = request.Headers["Pragma"];

if (pragma != null) {

pragmaDirectives = pragma.Split(s_fieldSeparators);

for (i = 0; i < pragmaDirectives.Length; i++) {

if (pragmaDirectives[i] == "no-cache") {

Debug.Trace("OutputCacheModuleEnter",

"Skipping lookup because of Pragma: no-cache directive." +

"\nReturning from OutputCacheModule::Enter");

RecordCacheMiss();

return;

}

}

}

}

else if (settings.ValidationCallbackInfo != null) {

/*

validationStatus = HttpValidationStatus.Valid;

validationStatusFinal = validationStatus;

for (i = 0, n = settings.ValidationCallbackInfo.Length; i < n; i++) {

callbackInfo = settings.ValidationCallbackInfo[i];

try {

callbackInfo.handler(context, callbackInfo.data, ref validationStatus);

}

catch (Exception e) {

validationStatus = HttpValidationStatus.Invalid;

HttpApplicationFactory.RaiseError(e);

}

switch (validationStatus) {

case HttpValidationStatus.Invalid:

Debug.Trace("OutputCacheModuleEnter", "Output cache item found but callback invalidated it." +

"\n\tkey=" + key +

"\nReturning from OutputCacheModule::Enter");

OutputCache.Remove(key, context);

RecordCacheMiss();

return;

case HttpValidationStatus.IgnoreThisRequest:

validationStatusFinal = HttpValidationStatus.IgnoreThisRequest;

break;

case HttpValidationStatus.Valid:

break;

default:

Debug.Trace("OutputCacheModuleEnter", "Invalid validation status, ignoring it, status=" + validationStatus +

"\n\tkey=" + key);

validationStatus = validationStatusFinal;

break;

}

}

if (validationStatusFinal == HttpValidationStatus.IgnoreThisRequest) {

Debug.Trace("OutputCacheModuleEnter", "Output cache item found but callback status is IgnoreThisRequest." +

"\n\tkey=" + key +

"\nReturning from OutputCacheModule::Enter");

RecordCacheMiss();

return;

}

Debug.Assert(validationStatusFinal == HttpValidationStatus.Valid,

"validationStatusFinal == HttpValidationStatus.Valid");

}

rawResponse = cachedRawResponse._rawResponse;

// WOS 1985154 ensure Content-Encoding is acceptable

if (cachedVary == null || cachedVary._contentEncodings == null) {

string acceptEncoding = request.Headers["Accept-Encoding"];

string contentEncoding = null;

ArrayList headers = rawResponse.Headers;

if (headers != null) {

foreach (HttpResponseHeader h in headers) {

if (h.Name == "Content-Encoding") {

contentEncoding = h.Value;

break;

}

}

}

if (!IsAcceptableEncoding(contentEncoding, acceptEncoding)) {

RecordCacheMiss();

return;

}

}

/*

send304 = -1;