Move WebCore into Source
[WebKit-https.git] / Source / WebCore / platform / network / ResourceResponseBase.cpp
1 /*
2  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
3  * Copyright (C) 2009 Google Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "ResourceResponseBase.h"
29
30 #include "HTTPParsers.h"
31 #include "ResourceResponse.h"
32 #include <wtf/CurrentTime.h>
33 #include <wtf/MathExtras.h>
34 #include <wtf/StdLibExtras.h>
35
36 using namespace std;
37
38 namespace WebCore {
39
40 static void parseCacheHeader(const String& header, Vector<pair<String, String> >& result);
41
42 inline const ResourceResponse& ResourceResponseBase::asResourceResponse() const
43 {
44     return *static_cast<const ResourceResponse*>(this);
45 }
46
47 ResourceResponseBase::ResourceResponseBase()  
48     : m_expectedContentLength(0)
49     , m_httpStatusCode(0)
50     , m_lastModifiedDate(0)
51     , m_wasCached(false)
52     , m_connectionID(0)
53     , m_connectionReused(false)
54     , m_isNull(true)
55     , m_haveParsedCacheControlHeader(false)
56     , m_haveParsedAgeHeader(false)
57     , m_haveParsedDateHeader(false)
58     , m_haveParsedExpiresHeader(false)
59     , m_haveParsedLastModifiedHeader(false)
60     , m_cacheControlContainsNoCache(false)
61     , m_cacheControlContainsNoStore(false)
62     , m_cacheControlContainsMustRevalidate(false)
63     , m_cacheControlMaxAge(0.0)
64     , m_age(0.0)
65     , m_date(0.0)
66     , m_expires(0.0)
67     , m_lastModified(0.0)
68 {
69 }
70
71 ResourceResponseBase::ResourceResponseBase(const KURL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)
72     : m_url(url)
73     , m_mimeType(mimeType)
74     , m_expectedContentLength(expectedLength)
75     , m_textEncodingName(textEncodingName)
76     , m_suggestedFilename(filename)
77     , m_httpStatusCode(0)
78     , m_lastModifiedDate(0)
79     , m_wasCached(false)
80     , m_connectionID(0)
81     , m_connectionReused(false)
82     , m_isNull(false)
83     , m_haveParsedCacheControlHeader(false)
84     , m_haveParsedAgeHeader(false)
85     , m_haveParsedDateHeader(false)
86     , m_haveParsedExpiresHeader(false)
87     , m_haveParsedLastModifiedHeader(false)
88     , m_cacheControlContainsNoCache(false)
89     , m_cacheControlContainsNoStore(false)
90     , m_cacheControlContainsMustRevalidate(false)
91     , m_cacheControlMaxAge(0.0)
92     , m_age(0.0)
93     , m_date(0.0)
94     , m_expires(0.0)
95     , m_lastModified(0.0)
96 {
97 }
98
99 PassOwnPtr<ResourceResponse> ResourceResponseBase::adopt(PassOwnPtr<CrossThreadResourceResponseData> data)
100 {
101     OwnPtr<ResourceResponse> response(new ResourceResponse());
102     response->setURL(data->m_url);
103     response->setMimeType(data->m_mimeType);
104     response->setExpectedContentLength(data->m_expectedContentLength);
105     response->setTextEncodingName(data->m_textEncodingName);
106     response->setSuggestedFilename(data->m_suggestedFilename);
107
108     response->setHTTPStatusCode(data->m_httpStatusCode);
109     response->setHTTPStatusText(data->m_httpStatusText);
110
111     response->lazyInit();
112     response->m_httpHeaderFields.adopt(data->m_httpHeaders.release());
113     response->setLastModifiedDate(data->m_lastModifiedDate);
114     response->setResourceLoadTiming(data->m_resourceLoadTiming.release());
115     response->doPlatformAdopt(data);
116     return response.release();
117 }
118
119 PassOwnPtr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const
120 {
121     OwnPtr<CrossThreadResourceResponseData> data(new CrossThreadResourceResponseData());
122     data->m_url = url().copy();
123     data->m_mimeType = mimeType().crossThreadString();
124     data->m_expectedContentLength = expectedContentLength();
125     data->m_textEncodingName = textEncodingName().crossThreadString();
126     data->m_suggestedFilename = suggestedFilename().crossThreadString();
127     data->m_httpStatusCode = httpStatusCode();
128     data->m_httpStatusText = httpStatusText().crossThreadString();
129     data->m_httpHeaders = httpHeaderFields().copyData();
130     data->m_lastModifiedDate = lastModifiedDate();
131     if (m_resourceLoadTiming)
132         data->m_resourceLoadTiming = m_resourceLoadTiming->deepCopy();
133     return asResourceResponse().doPlatformCopyData(data.release());
134 }
135
136 bool ResourceResponseBase::isHTTP() const
137 {
138     lazyInit();
139
140     String protocol = m_url.protocol();
141
142     return equalIgnoringCase(protocol, "http")  || equalIgnoringCase(protocol, "https");
143 }
144
145 const KURL& ResourceResponseBase::url() const
146 {
147     lazyInit();
148     
149     return m_url; 
150 }
151
152 void ResourceResponseBase::setURL(const KURL& url)
153 {
154     lazyInit();
155     m_isNull = false;
156     
157     m_url = url; 
158 }
159
160 const String& ResourceResponseBase::mimeType() const
161 {
162     lazyInit();
163
164     return m_mimeType; 
165 }
166
167 void ResourceResponseBase::setMimeType(const String& mimeType)
168 {
169     lazyInit();
170     m_isNull = false;
171     
172     m_mimeType = mimeType; 
173 }
174
175 long long ResourceResponseBase::expectedContentLength() const 
176 {
177     lazyInit();
178
179     return m_expectedContentLength;
180 }
181
182 void ResourceResponseBase::setExpectedContentLength(long long expectedContentLength)
183 {
184     lazyInit();
185     m_isNull = false;
186     
187     m_expectedContentLength = expectedContentLength; 
188 }
189
190 const String& ResourceResponseBase::textEncodingName() const
191 {
192     lazyInit();
193
194     return m_textEncodingName;
195 }
196
197 void ResourceResponseBase::setTextEncodingName(const String& encodingName)
198 {
199     lazyInit();
200     m_isNull = false;
201     
202     m_textEncodingName = encodingName; 
203 }
204
205 // FIXME should compute this on the fly
206 const String& ResourceResponseBase::suggestedFilename() const
207 {
208     lazyInit();
209
210     return m_suggestedFilename;
211 }
212
213 void ResourceResponseBase::setSuggestedFilename(const String& suggestedName)
214 {
215     lazyInit();
216     m_isNull = false;
217     
218     m_suggestedFilename = suggestedName; 
219 }
220
221 int ResourceResponseBase::httpStatusCode() const
222 {
223     lazyInit();
224
225     return m_httpStatusCode;
226 }
227
228 void ResourceResponseBase::setHTTPStatusCode(int statusCode)
229 {
230     lazyInit();
231
232     m_httpStatusCode = statusCode;
233 }
234
235 const String& ResourceResponseBase::httpStatusText() const 
236 {
237     lazyInit();
238
239     return m_httpStatusText; 
240 }
241
242 void ResourceResponseBase::setHTTPStatusText(const String& statusText) 
243 {
244     lazyInit();
245
246     m_httpStatusText = statusText; 
247 }
248
249 String ResourceResponseBase::httpHeaderField(const AtomicString& name) const
250 {
251     lazyInit();
252
253     return m_httpHeaderFields.get(name); 
254 }
255
256 String ResourceResponseBase::httpHeaderField(const char* name) const
257 {
258     lazyInit();
259
260     return m_httpHeaderFields.get(name); 
261 }
262
263 void ResourceResponseBase::setHTTPHeaderField(const AtomicString& name, const String& value)
264 {
265     lazyInit();
266     
267     DEFINE_STATIC_LOCAL(const AtomicString, ageHeader, ("age"));
268     DEFINE_STATIC_LOCAL(const AtomicString, cacheControlHeader, ("cache-control"));
269     DEFINE_STATIC_LOCAL(const AtomicString, dateHeader, ("date"));
270     DEFINE_STATIC_LOCAL(const AtomicString, expiresHeader, ("expires"));
271     DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified"));
272     DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma"));
273     if (equalIgnoringCase(name, ageHeader))
274         m_haveParsedAgeHeader = false;
275     else if (equalIgnoringCase(name, cacheControlHeader) || equalIgnoringCase(name, pragmaHeader))
276         m_haveParsedCacheControlHeader = false;
277     else if (equalIgnoringCase(name, dateHeader))
278         m_haveParsedDateHeader = false;
279     else if (equalIgnoringCase(name, expiresHeader))
280         m_haveParsedExpiresHeader = false;
281     else if (equalIgnoringCase(name, lastModifiedHeader))
282         m_haveParsedLastModifiedHeader = false;
283
284     m_httpHeaderFields.set(name, value);
285 }
286
287 const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const
288 {
289     lazyInit();
290
291     return m_httpHeaderFields;
292 }
293
294 void ResourceResponseBase::parseCacheControlDirectives() const
295 {
296     ASSERT(!m_haveParsedCacheControlHeader);
297
298     lazyInit();
299
300     m_haveParsedCacheControlHeader = true;
301
302     m_cacheControlContainsMustRevalidate = false;
303     m_cacheControlContainsNoCache = false;
304     m_cacheControlMaxAge = numeric_limits<double>::quiet_NaN();
305
306     DEFINE_STATIC_LOCAL(const AtomicString, cacheControlString, ("cache-control"));
307     DEFINE_STATIC_LOCAL(const AtomicString, noCacheDirective, ("no-cache"));
308     DEFINE_STATIC_LOCAL(const AtomicString, noStoreDirective, ("no-store"));
309     DEFINE_STATIC_LOCAL(const AtomicString, mustRevalidateDirective, ("must-revalidate"));
310     DEFINE_STATIC_LOCAL(const AtomicString, maxAgeDirective, ("max-age"));
311
312     String cacheControlValue = m_httpHeaderFields.get(cacheControlString);
313     if (!cacheControlValue.isEmpty()) {
314         Vector<pair<String, String> > directives;
315         parseCacheHeader(cacheControlValue, directives);
316
317         size_t directivesSize = directives.size();
318         for (size_t i = 0; i < directivesSize; ++i) {
319             // RFC2616 14.9.1: A no-cache directive with a value is only meaningful for proxy caches.
320             // It should be ignored by a browser level cache.
321             if (equalIgnoringCase(directives[i].first, noCacheDirective) && directives[i].second.isEmpty())
322                 m_cacheControlContainsNoCache = true;
323             else if (equalIgnoringCase(directives[i].first, noStoreDirective))
324                 m_cacheControlContainsNoStore = true;
325             else if (equalIgnoringCase(directives[i].first, mustRevalidateDirective))
326                 m_cacheControlContainsMustRevalidate = true;
327             else if (equalIgnoringCase(directives[i].first, maxAgeDirective)) {
328                 bool ok;
329                 double maxAge = directives[i].second.toDouble(&ok);
330                 if (ok)
331                     m_cacheControlMaxAge = maxAge;
332             }
333         }
334     }
335         
336     if (!m_cacheControlContainsNoCache) {
337         // Handle Pragma: no-cache
338         // This is deprecated and equivalent to Cache-control: no-cache
339         // Don't bother tokenizing the value, it is not important
340         DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma"));
341         String pragmaValue = m_httpHeaderFields.get(pragmaHeader);
342         m_cacheControlContainsNoCache = pragmaValue.lower().contains(noCacheDirective);
343     }
344 }
345     
346 bool ResourceResponseBase::cacheControlContainsNoCache() const
347 {
348     if (!m_haveParsedCacheControlHeader)
349         parseCacheControlDirectives();
350     return m_cacheControlContainsNoCache;
351 }
352
353 bool ResourceResponseBase::cacheControlContainsNoStore() const
354 {
355     if (!m_haveParsedCacheControlHeader)
356         parseCacheControlDirectives();
357     return m_cacheControlContainsNoStore;
358 }
359
360 bool ResourceResponseBase::cacheControlContainsMustRevalidate() const
361 {
362     if (!m_haveParsedCacheControlHeader)
363         parseCacheControlDirectives();
364     return m_cacheControlContainsMustRevalidate;
365 }
366
367 double ResourceResponseBase::cacheControlMaxAge() const
368 {
369     if (!m_haveParsedCacheControlHeader)
370         parseCacheControlDirectives();
371     return m_cacheControlMaxAge;
372 }
373
374 static double parseDateValueInHeader(const HTTPHeaderMap& headers, const AtomicString& headerName)
375 {
376     String headerValue = headers.get(headerName);
377     if (headerValue.isEmpty())
378         return std::numeric_limits<double>::quiet_NaN(); 
379     // This handles all date formats required by RFC2616:
380     // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
381     // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
382     // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
383     double dateInMilliseconds = parseDate(headerValue);
384     if (!isfinite(dateInMilliseconds))
385         return std::numeric_limits<double>::quiet_NaN();
386     return dateInMilliseconds / 1000;
387 }
388
389 double ResourceResponseBase::date() const
390 {
391     lazyInit();
392
393     if (!m_haveParsedDateHeader) {
394         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("date"));
395         m_date = parseDateValueInHeader(m_httpHeaderFields, headerName);
396         m_haveParsedDateHeader = true;
397     }
398     return m_date;
399 }
400
401 double ResourceResponseBase::age() const
402 {
403     lazyInit();
404     
405     if (!m_haveParsedAgeHeader) {
406         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("age"));
407         String headerValue = m_httpHeaderFields.get(headerName);
408         bool ok;
409         m_age = headerValue.toDouble(&ok);
410         if (!ok)
411             m_age = std::numeric_limits<double>::quiet_NaN();
412         m_haveParsedAgeHeader = true;
413     }
414     return m_age;
415 }
416
417 double ResourceResponseBase::expires() const
418 {
419     lazyInit();
420
421     if (!m_haveParsedExpiresHeader) {
422         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("expires"));
423         m_expires = parseDateValueInHeader(m_httpHeaderFields, headerName);
424         m_haveParsedExpiresHeader = true;
425     }
426     return m_expires;
427 }
428
429 double ResourceResponseBase::lastModified() const
430 {
431     lazyInit();
432     
433     if (!m_haveParsedLastModifiedHeader) {
434         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("last-modified"));
435         m_lastModified = parseDateValueInHeader(m_httpHeaderFields, headerName);
436         m_haveParsedLastModifiedHeader = true;
437     }
438     return m_lastModified;
439 }
440
441 bool ResourceResponseBase::isAttachment() const
442 {
443     lazyInit();
444
445     DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("content-disposition"));
446     String value = m_httpHeaderFields.get(headerName);
447     size_t loc = value.find(';');
448     if (loc != notFound)
449         value = value.left(loc);
450     value = value.stripWhiteSpace();
451     DEFINE_STATIC_LOCAL(const AtomicString, attachmentString, ("attachment"));
452     return equalIgnoringCase(value, attachmentString);
453 }
454   
455 void ResourceResponseBase::setLastModifiedDate(time_t lastModifiedDate)
456 {
457     lazyInit();
458
459     m_lastModifiedDate = lastModifiedDate;
460 }
461
462 time_t ResourceResponseBase::lastModifiedDate() const
463 {
464     lazyInit();
465
466     return m_lastModifiedDate;
467 }
468
469 bool ResourceResponseBase::wasCached() const
470 {
471     lazyInit();
472
473     return m_wasCached;
474 }
475
476 void ResourceResponseBase::setWasCached(bool value)
477 {
478     m_wasCached = value;
479 }
480
481 bool ResourceResponseBase::connectionReused() const
482 {
483     lazyInit();
484
485     return m_connectionReused;
486 }
487
488 void ResourceResponseBase::setConnectionReused(bool connectionReused)
489 {
490     lazyInit();
491
492     m_connectionReused = connectionReused;
493 }
494
495 unsigned ResourceResponseBase::connectionID() const
496 {
497     lazyInit();
498
499     return m_connectionID;
500 }
501
502 void ResourceResponseBase::setConnectionID(unsigned connectionID)
503 {
504     lazyInit();
505
506     m_connectionID = connectionID;
507 }
508
509 ResourceLoadTiming* ResourceResponseBase::resourceLoadTiming() const
510 {
511     lazyInit();
512
513     return m_resourceLoadTiming.get();
514 }
515
516 void ResourceResponseBase::setResourceLoadTiming(PassRefPtr<ResourceLoadTiming> resourceLoadTiming)
517 {
518     lazyInit();
519
520     m_resourceLoadTiming = resourceLoadTiming;
521 }
522
523 PassRefPtr<ResourceLoadInfo> ResourceResponseBase::resourceLoadInfo() const
524 {
525     lazyInit();
526
527     return m_resourceLoadInfo.get();
528 }
529
530 void ResourceResponseBase::setResourceLoadInfo(PassRefPtr<ResourceLoadInfo> loadInfo)
531 {
532     lazyInit();
533
534     m_resourceLoadInfo = loadInfo;
535 }
536
537 void ResourceResponseBase::lazyInit() const
538 {
539     const_cast<ResourceResponse*>(static_cast<const ResourceResponse*>(this))->platformLazyInit();
540 }
541
542 bool ResourceResponseBase::compare(const ResourceResponse& a, const ResourceResponse& b)
543 {
544     if (a.isNull() != b.isNull())
545         return false;  
546     if (a.url() != b.url())
547         return false;
548     if (a.mimeType() != b.mimeType())
549         return false;
550     if (a.expectedContentLength() != b.expectedContentLength())
551         return false;
552     if (a.textEncodingName() != b.textEncodingName())
553         return false;
554     if (a.suggestedFilename() != b.suggestedFilename())
555         return false;
556     if (a.httpStatusCode() != b.httpStatusCode())
557         return false;
558     if (a.httpStatusText() != b.httpStatusText())
559         return false;
560     if (a.httpHeaderFields() != b.httpHeaderFields())
561         return false;
562     if (a.resourceLoadTiming() && b.resourceLoadTiming() && *a.resourceLoadTiming() == *b.resourceLoadTiming())
563         return ResourceResponse::platformCompare(a, b);
564     if (a.resourceLoadTiming() != b.resourceLoadTiming())
565         return false;
566     return ResourceResponse::platformCompare(a, b);
567 }
568
569 static bool isCacheHeaderSeparator(UChar c)
570 {
571     // See RFC 2616, Section 2.2
572     switch (c) {
573         case '(':
574         case ')':
575         case '<':
576         case '>':
577         case '@':
578         case ',':
579         case ';':
580         case ':':
581         case '\\':
582         case '"':
583         case '/':
584         case '[':
585         case ']':
586         case '?':
587         case '=':
588         case '{':
589         case '}':
590         case ' ':
591         case '\t':
592             return true;
593         default:
594             return false;
595     }
596 }
597
598 static bool isControlCharacter(UChar c)
599 {
600     return c < ' ' || c == 127;
601 }
602
603 static inline String trimToNextSeparator(const String& str)
604 {
605     return str.substring(0, str.find(isCacheHeaderSeparator, 0));
606 }
607
608 static void parseCacheHeader(const String& header, Vector<pair<String, String> >& result)
609 {
610     const String safeHeader = header.removeCharacters(isControlCharacter);
611     unsigned max = safeHeader.length();
612     for (unsigned pos = 0; pos < max; /* pos incremented in loop */) {
613         size_t nextCommaPosition = safeHeader.find(',', pos);
614         size_t nextEqualSignPosition = safeHeader.find('=', pos);
615         if (nextEqualSignPosition != notFound && (nextEqualSignPosition < nextCommaPosition || nextCommaPosition == notFound)) {
616             // Get directive name, parse right hand side of equal sign, then add to map
617             String directive = trimToNextSeparator(safeHeader.substring(pos, nextEqualSignPosition - pos).stripWhiteSpace());
618             pos += nextEqualSignPosition - pos + 1;
619
620             String value = safeHeader.substring(pos, max - pos).stripWhiteSpace();
621             if (value[0] == '"') {
622                 // The value is a quoted string
623                 size_t nextDoubleQuotePosition = value.find('"', 1);
624                 if (nextDoubleQuotePosition != notFound) {
625                     // Store the value as a quoted string without quotes
626                     result.append(pair<String, String>(directive, value.substring(1, nextDoubleQuotePosition - 1).stripWhiteSpace()));
627                     pos += (safeHeader.find('"', pos) - pos) + nextDoubleQuotePosition + 1;
628                     // Move past next comma, if there is one
629                     size_t nextCommaPosition2 = safeHeader.find(',', pos);
630                     if (nextCommaPosition2 != notFound)
631                         pos += nextCommaPosition2 - pos + 1;
632                     else
633                         return; // Parse error if there is anything left with no comma
634                 } else {
635                     // Parse error; just use the rest as the value
636                     result.append(pair<String, String>(directive, trimToNextSeparator(value.substring(1, value.length() - 1).stripWhiteSpace())));
637                     return;
638                 }
639             } else {
640                 // The value is a token until the next comma
641                 size_t nextCommaPosition2 = value.find(',', 0);
642                 if (nextCommaPosition2 != notFound) {
643                     // The value is delimited by the next comma
644                     result.append(pair<String, String>(directive, trimToNextSeparator(value.substring(0, nextCommaPosition2).stripWhiteSpace())));
645                     pos += (safeHeader.find(',', pos) - pos) + 1;
646                 } else {
647                     // The rest is the value; no change to value needed
648                     result.append(pair<String, String>(directive, trimToNextSeparator(value)));
649                     return;
650                 }
651             }
652         } else if (nextCommaPosition != notFound && (nextCommaPosition < nextEqualSignPosition || nextEqualSignPosition == notFound)) {
653             // Add directive to map with empty string as value
654             result.append(pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, nextCommaPosition - pos).stripWhiteSpace()), ""));
655             pos += nextCommaPosition - pos + 1;
656         } else {
657             // Add last directive to map with empty string as value
658             result.append(pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, max - pos).stripWhiteSpace()), ""));
659             return;
660         }
661     }
662 }
663
664 }