Add WTF::move()
[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 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 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 "HTTPHeaderNames.h"
31 #include "HTTPParsers.h"
32 #include "ResourceResponse.h"
33 #include <wtf/CurrentTime.h>
34 #include <wtf/MathExtras.h>
35 #include <wtf/StdLibExtras.h>
36 #include <wtf/text/StringView.h>
37
38 namespace WebCore {
39
40 static void parseCacheHeader(const String& header, Vector<std::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_connectionID(0)
51     , m_cacheControlMaxAge(0)
52     , m_age(0)
53     , m_date(0)
54     , m_expires(0)
55     , m_lastModified(0)
56     , m_wasCached(false)
57     , m_connectionReused(false)
58     , m_isNull(true)
59     , m_haveParsedCacheControlHeader(false)
60     , m_haveParsedAgeHeader(false)
61     , m_haveParsedDateHeader(false)
62     , m_haveParsedExpiresHeader(false)
63     , m_haveParsedLastModifiedHeader(false)
64     , m_cacheControlContainsNoCache(false)
65     , m_cacheControlContainsNoStore(false)
66     , m_cacheControlContainsMustRevalidate(false)
67 {
68 }
69
70 ResourceResponseBase::ResourceResponseBase(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)
71     : m_url(url)
72     , m_mimeType(mimeType)
73     , m_expectedContentLength(expectedLength)
74     , m_textEncodingName(textEncodingName)
75     , m_suggestedFilename(filename)
76     , m_httpStatusCode(0)
77     , m_connectionID(0)
78     , m_cacheControlMaxAge(0)
79     , m_age(0)
80     , m_date(0)
81     , m_expires(0)
82     , m_lastModified(0)
83     , m_wasCached(false)
84     , m_connectionReused(false)
85     , m_isNull(false)
86     , m_haveParsedCacheControlHeader(false)
87     , m_haveParsedAgeHeader(false)
88     , m_haveParsedDateHeader(false)
89     , m_haveParsedExpiresHeader(false)
90     , m_haveParsedLastModifiedHeader(false)
91     , m_cacheControlContainsNoCache(false)
92     , m_cacheControlContainsNoStore(false)
93     , m_cacheControlContainsMustRevalidate(false)
94 {
95 }
96
97 PassOwnPtr<ResourceResponse> ResourceResponseBase::adopt(PassOwnPtr<CrossThreadResourceResponseData> data)
98 {
99     OwnPtr<ResourceResponse> response = adoptPtr(new ResourceResponse);
100     response->setURL(data->m_url);
101     response->setMimeType(data->m_mimeType);
102     response->setExpectedContentLength(data->m_expectedContentLength);
103     response->setTextEncodingName(data->m_textEncodingName);
104     response->setSuggestedFilename(data->m_suggestedFilename);
105
106     response->setHTTPStatusCode(data->m_httpStatusCode);
107     response->setHTTPStatusText(data->m_httpStatusText);
108
109     response->lazyInit(CommonAndUncommonFields);
110     response->m_httpHeaderFields.adopt(WTF::move(data->m_httpHeaders));
111     response->m_resourceLoadTiming = data->m_resourceLoadTiming;
112     response->doPlatformAdopt(data);
113     return response.release();
114 }
115
116 PassOwnPtr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const
117 {
118     OwnPtr<CrossThreadResourceResponseData> data = adoptPtr(new CrossThreadResourceResponseData);
119     data->m_url = url().copy();
120     data->m_mimeType = mimeType().isolatedCopy();
121     data->m_expectedContentLength = expectedContentLength();
122     data->m_textEncodingName = textEncodingName().isolatedCopy();
123     data->m_suggestedFilename = suggestedFilename().isolatedCopy();
124     data->m_httpStatusCode = httpStatusCode();
125     data->m_httpStatusText = httpStatusText().isolatedCopy();
126     data->m_httpHeaders = httpHeaderFields().copyData();
127     data->m_resourceLoadTiming = m_resourceLoadTiming;
128     return asResourceResponse().doPlatformCopyData(data.release());
129 }
130
131 bool ResourceResponseBase::isHTTP() const
132 {
133     lazyInit(CommonFieldsOnly);
134
135     String protocol = m_url.protocol();
136
137     return equalIgnoringCase(protocol, "http")  || equalIgnoringCase(protocol, "https");
138 }
139
140 const URL& ResourceResponseBase::url() const
141 {
142     lazyInit(CommonFieldsOnly);
143
144     return m_url; 
145 }
146
147 void ResourceResponseBase::setURL(const URL& url)
148 {
149     lazyInit(CommonFieldsOnly);
150     m_isNull = false;
151
152     m_url = url;
153
154     // FIXME: Should invalidate or update platform response if present.
155 }
156
157 const String& ResourceResponseBase::mimeType() const
158 {
159     lazyInit(CommonFieldsOnly);
160
161     return m_mimeType; 
162 }
163
164 void ResourceResponseBase::setMimeType(const String& mimeType)
165 {
166     lazyInit(CommonFieldsOnly);
167     m_isNull = false;
168
169     // FIXME: MIME type is determined by HTTP Content-Type header. We should update the header, so that it doesn't disagree with m_mimeType.
170     m_mimeType = mimeType;
171
172     // FIXME: Should invalidate or update platform response if present.
173 }
174
175 long long ResourceResponseBase::expectedContentLength() const 
176 {
177     lazyInit(CommonFieldsOnly);
178
179     return m_expectedContentLength;
180 }
181
182 void ResourceResponseBase::setExpectedContentLength(long long expectedContentLength)
183 {
184     lazyInit(CommonFieldsOnly);
185     m_isNull = false;
186
187     // FIXME: Content length is determined by HTTP Content-Length header. We should update the header, so that it doesn't disagree with m_expectedContentLength.
188     m_expectedContentLength = expectedContentLength; 
189
190     // FIXME: Should invalidate or update platform response if present.
191 }
192
193 const String& ResourceResponseBase::textEncodingName() const
194 {
195     lazyInit(CommonFieldsOnly);
196
197     return m_textEncodingName;
198 }
199
200 void ResourceResponseBase::setTextEncodingName(const String& encodingName)
201 {
202     lazyInit(CommonFieldsOnly);
203     m_isNull = false;
204
205     // FIXME: Text encoding is determined by HTTP Content-Type header. We should update the header, so that it doesn't disagree with m_textEncodingName.
206     m_textEncodingName = encodingName;
207
208     // FIXME: Should invalidate or update platform response if present.
209 }
210
211 // FIXME should compute this on the fly
212 const String& ResourceResponseBase::suggestedFilename() const
213 {
214     lazyInit(AllFields);
215
216     return m_suggestedFilename;
217 }
218
219 void ResourceResponseBase::setSuggestedFilename(const String& suggestedName)
220 {
221     lazyInit(AllFields);
222     m_isNull = false;
223
224     // FIXME: Suggested file name is calculated based on other headers. There should not be a setter for it.
225     m_suggestedFilename = suggestedName; 
226
227     // FIXME: Should invalidate or update platform response if present.
228 }
229
230 int ResourceResponseBase::httpStatusCode() const
231 {
232     lazyInit(CommonFieldsOnly);
233
234     return m_httpStatusCode;
235 }
236
237 void ResourceResponseBase::setHTTPStatusCode(int statusCode)
238 {
239     lazyInit(CommonFieldsOnly);
240
241     m_httpStatusCode = statusCode;
242
243     // FIXME: Should invalidate or update platform response if present.
244 }
245
246 const String& ResourceResponseBase::httpStatusText() const 
247 {
248     lazyInit(CommonAndUncommonFields);
249
250     return m_httpStatusText; 
251 }
252
253 void ResourceResponseBase::setHTTPStatusText(const String& statusText) 
254 {
255     lazyInit(CommonAndUncommonFields);
256
257     m_httpStatusText = statusText; 
258
259     // FIXME: Should invalidate or update platform response if present.
260 }
261
262 String ResourceResponseBase::httpHeaderField(const String& name) const
263 {
264     lazyInit(CommonFieldsOnly);
265
266     // If we already have the header, just return it instead of consuming memory by grabing all headers.
267     String value = m_httpHeaderFields.get(name);
268     if (!value.isEmpty())        
269         return value;
270
271     lazyInit(CommonAndUncommonFields);
272
273     return m_httpHeaderFields.get(name); 
274 }
275
276 String ResourceResponseBase::httpHeaderField(HTTPHeaderName name) const
277 {
278     lazyInit(CommonFieldsOnly);
279
280     // If we already have the header, just return it instead of consuming memory by grabing all headers.
281     String value = m_httpHeaderFields.get(name);
282     if (!value.isEmpty())
283         return value;
284
285     lazyInit(CommonAndUncommonFields);
286
287     return m_httpHeaderFields.get(name); 
288 }
289
290 void ResourceResponseBase::updateHeaderParsedState(HTTPHeaderName name)
291 {
292     switch (name) {
293     case HTTPHeaderName::Age:
294         m_haveParsedAgeHeader = false;
295         break;
296
297     case HTTPHeaderName::CacheControl:
298     case HTTPHeaderName::Pragma:
299         m_haveParsedCacheControlHeader = false;
300         break;
301
302     case HTTPHeaderName::Date:
303         m_haveParsedDateHeader = false;
304         break;
305
306     case HTTPHeaderName::Expires:
307         m_haveParsedExpiresHeader = false;
308         break;
309
310     case HTTPHeaderName::LastModified:
311         m_haveParsedLastModifiedHeader = false;
312         break;
313
314     default:
315         break;
316     }
317 }
318
319 void ResourceResponseBase::setHTTPHeaderField(const String& name, const String& value)
320 {
321     lazyInit(CommonAndUncommonFields);
322
323     HTTPHeaderName headerName;
324     if (findHTTPHeaderName(name, headerName))
325         updateHeaderParsedState(headerName);
326
327     m_httpHeaderFields.set(name, value);
328
329     // FIXME: Should invalidate or update platform response if present.
330 }
331
332 void ResourceResponseBase::setHTTPHeaderField(HTTPHeaderName name, const String& value)
333 {
334     lazyInit(CommonAndUncommonFields);
335
336     updateHeaderParsedState(name);
337
338     m_httpHeaderFields.set(name, value);
339
340     // FIXME: Should invalidate or update platform response if present.
341 }
342
343 void ResourceResponseBase::addHTTPHeaderField(const String& name, const String& value)
344 {
345     lazyInit(CommonAndUncommonFields);
346
347     HTTPHeaderName headerName;
348     if (findHTTPHeaderName(name, headerName))
349         updateHeaderParsedState(headerName);
350
351     m_httpHeaderFields.add(name, value);
352 }
353
354 const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const
355 {
356     lazyInit(CommonAndUncommonFields);
357
358     return m_httpHeaderFields;
359 }
360
361 void ResourceResponseBase::parseCacheControlDirectives() const
362 {
363     ASSERT(!m_haveParsedCacheControlHeader);
364
365     lazyInit(CommonFieldsOnly);
366
367     m_haveParsedCacheControlHeader = true;
368
369     m_cacheControlContainsMustRevalidate = false;
370     m_cacheControlContainsNoCache = false;
371     m_cacheControlMaxAge = std::numeric_limits<double>::quiet_NaN();
372
373     String cacheControlValue = m_httpHeaderFields.get(HTTPHeaderName::CacheControl);
374     if (!cacheControlValue.isEmpty()) {
375         Vector<std::pair<String, String>> directives;
376         parseCacheHeader(cacheControlValue, directives);
377
378         size_t directivesSize = directives.size();
379         for (size_t i = 0; i < directivesSize; ++i) {
380             // RFC2616 14.9.1: A no-cache directive with a value is only meaningful for proxy caches.
381             // It should be ignored by a browser level cache.
382             if (equalIgnoringCase(directives[i].first, "no-cache") && directives[i].second.isEmpty())
383                 m_cacheControlContainsNoCache = true;
384             else if (equalIgnoringCase(directives[i].first, "no-store"))
385                 m_cacheControlContainsNoStore = true;
386             else if (equalIgnoringCase(directives[i].first, "must-revalidate"))
387                 m_cacheControlContainsMustRevalidate = true;
388             else if (equalIgnoringCase(directives[i].first, "max-age")) {
389                 if (!std::isnan(m_cacheControlMaxAge)) {
390                     // First max-age directive wins if there are multiple ones.
391                     continue;
392                 }
393                 bool ok;
394                 double maxAge = directives[i].second.toDouble(&ok);
395                 if (ok)
396                     m_cacheControlMaxAge = maxAge;
397             }
398         }
399     }
400
401     if (!m_cacheControlContainsNoCache) {
402         // Handle Pragma: no-cache
403         // This is deprecated and equivalent to Cache-control: no-cache
404         // Don't bother tokenizing the value, it is not important
405         String pragmaValue = m_httpHeaderFields.get(HTTPHeaderName::Pragma);
406
407         m_cacheControlContainsNoCache = pragmaValue.contains("no-cache", false);
408     }
409 }
410     
411 bool ResourceResponseBase::cacheControlContainsNoCache() const
412 {
413     if (!m_haveParsedCacheControlHeader)
414         parseCacheControlDirectives();
415     return m_cacheControlContainsNoCache;
416 }
417
418 bool ResourceResponseBase::cacheControlContainsNoStore() const
419 {
420     if (!m_haveParsedCacheControlHeader)
421         parseCacheControlDirectives();
422     return m_cacheControlContainsNoStore;
423 }
424
425 bool ResourceResponseBase::cacheControlContainsMustRevalidate() const
426 {
427     if (!m_haveParsedCacheControlHeader)
428         parseCacheControlDirectives();
429     return m_cacheControlContainsMustRevalidate;
430 }
431
432 bool ResourceResponseBase::hasCacheValidatorFields() const
433 {
434     lazyInit(CommonFieldsOnly);
435
436     return !m_httpHeaderFields.get(HTTPHeaderName::LastModified).isEmpty() || !m_httpHeaderFields.get(HTTPHeaderName::ETag).isEmpty();
437 }
438
439 double ResourceResponseBase::cacheControlMaxAge() const
440 {
441     if (!m_haveParsedCacheControlHeader)
442         parseCacheControlDirectives();
443     return m_cacheControlMaxAge;
444 }
445
446 static double parseDateValueInHeader(const HTTPHeaderMap& headers, HTTPHeaderName headerName)
447 {
448     String headerValue = headers.get(headerName);
449     if (headerValue.isEmpty())
450         return std::numeric_limits<double>::quiet_NaN(); 
451     // This handles all date formats required by RFC2616:
452     // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
453     // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
454     // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
455     double dateInMilliseconds = parseDate(headerValue);
456     if (!std::isfinite(dateInMilliseconds))
457         return std::numeric_limits<double>::quiet_NaN();
458     return dateInMilliseconds / 1000;
459 }
460
461 double ResourceResponseBase::date() const
462 {
463     lazyInit(CommonFieldsOnly);
464
465     if (!m_haveParsedDateHeader) {
466         m_date = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::Date);
467         m_haveParsedDateHeader = true;
468     }
469     return m_date;
470 }
471
472 double ResourceResponseBase::age() const
473 {
474     lazyInit(CommonFieldsOnly);
475
476     if (!m_haveParsedAgeHeader) {
477         String headerValue = m_httpHeaderFields.get(HTTPHeaderName::Age);
478         bool ok;
479         m_age = headerValue.toDouble(&ok);
480         if (!ok)
481             m_age = std::numeric_limits<double>::quiet_NaN();
482         m_haveParsedAgeHeader = true;
483     }
484     return m_age;
485 }
486
487 double ResourceResponseBase::expires() const
488 {
489     lazyInit(CommonFieldsOnly);
490
491     if (!m_haveParsedExpiresHeader) {
492         m_expires = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::Expires);
493         m_haveParsedExpiresHeader = true;
494     }
495     return m_expires;
496 }
497
498 double ResourceResponseBase::lastModified() const
499 {
500     lazyInit(CommonFieldsOnly);
501
502     if (!m_haveParsedLastModifiedHeader) {
503         m_lastModified = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::LastModified);
504         m_haveParsedLastModifiedHeader = true;
505     }
506     return m_lastModified;
507 }
508
509 bool ResourceResponseBase::isAttachment() const
510 {
511     lazyInit(CommonAndUncommonFields);
512
513     String value = m_httpHeaderFields.get(HTTPHeaderName::ContentDisposition);
514     size_t loc = value.find(';');
515     if (loc != notFound)
516         value = value.left(loc);
517     value = value.stripWhiteSpace();
518
519     return equalIgnoringCase(value, "attachment");
520 }
521   
522 bool ResourceResponseBase::wasCached() const
523 {
524     lazyInit(CommonAndUncommonFields);
525
526     return m_wasCached;
527 }
528
529 void ResourceResponseBase::setWasCached(bool value)
530 {
531     m_wasCached = value;
532 }
533
534 bool ResourceResponseBase::connectionReused() const
535 {
536     lazyInit(CommonAndUncommonFields);
537
538     return m_connectionReused;
539 }
540
541 void ResourceResponseBase::setConnectionReused(bool connectionReused)
542 {
543     lazyInit(CommonAndUncommonFields);
544
545     m_connectionReused = connectionReused;
546 }
547
548 unsigned ResourceResponseBase::connectionID() const
549 {
550     lazyInit(CommonAndUncommonFields);
551
552     return m_connectionID;
553 }
554
555 void ResourceResponseBase::setConnectionID(unsigned connectionID)
556 {
557     lazyInit(CommonAndUncommonFields);
558
559     m_connectionID = connectionID;
560 }
561
562 void ResourceResponseBase::lazyInit(InitLevel initLevel) const
563 {
564     const_cast<ResourceResponse*>(static_cast<const ResourceResponse*>(this))->platformLazyInit(initLevel);
565 }
566
567 bool ResourceResponseBase::compare(const ResourceResponse& a, const ResourceResponse& b)
568 {
569     if (a.isNull() != b.isNull())
570         return false;  
571     if (a.url() != b.url())
572         return false;
573     if (a.mimeType() != b.mimeType())
574         return false;
575     if (a.expectedContentLength() != b.expectedContentLength())
576         return false;
577     if (a.textEncodingName() != b.textEncodingName())
578         return false;
579     if (a.suggestedFilename() != b.suggestedFilename())
580         return false;
581     if (a.httpStatusCode() != b.httpStatusCode())
582         return false;
583     if (a.httpStatusText() != b.httpStatusText())
584         return false;
585     if (a.httpHeaderFields() != b.httpHeaderFields())
586         return false;
587     if (a.resourceLoadTiming() != b.resourceLoadTiming())
588         return false;
589     return ResourceResponse::platformCompare(a, b);
590 }
591
592 static bool isCacheHeaderSeparator(UChar c)
593 {
594     // See RFC 2616, Section 2.2
595     switch (c) {
596         case '(':
597         case ')':
598         case '<':
599         case '>':
600         case '@':
601         case ',':
602         case ';':
603         case ':':
604         case '\\':
605         case '"':
606         case '/':
607         case '[':
608         case ']':
609         case '?':
610         case '=':
611         case '{':
612         case '}':
613         case ' ':
614         case '\t':
615             return true;
616         default:
617             return false;
618     }
619 }
620
621 static bool isControlCharacter(UChar c)
622 {
623     return c < ' ' || c == 127;
624 }
625
626 static inline String trimToNextSeparator(const String& str)
627 {
628     return str.substring(0, str.find(isCacheHeaderSeparator));
629 }
630
631 static void parseCacheHeader(const String& header, Vector<std::pair<String, String>>& result)
632 {
633     const String safeHeader = header.removeCharacters(isControlCharacter);
634     unsigned max = safeHeader.length();
635     for (unsigned pos = 0; pos < max; /* pos incremented in loop */) {
636         size_t nextCommaPosition = safeHeader.find(',', pos);
637         size_t nextEqualSignPosition = safeHeader.find('=', pos);
638         if (nextEqualSignPosition != notFound && (nextEqualSignPosition < nextCommaPosition || nextCommaPosition == notFound)) {
639             // Get directive name, parse right hand side of equal sign, then add to map
640             String directive = trimToNextSeparator(safeHeader.substring(pos, nextEqualSignPosition - pos).stripWhiteSpace());
641             pos += nextEqualSignPosition - pos + 1;
642
643             String value = safeHeader.substring(pos, max - pos).stripWhiteSpace();
644             if (value[0] == '"') {
645                 // The value is a quoted string
646                 size_t nextDoubleQuotePosition = value.find('"', 1);
647                 if (nextDoubleQuotePosition != notFound) {
648                     // Store the value as a quoted string without quotes
649                     result.append(std::pair<String, String>(directive, value.substring(1, nextDoubleQuotePosition - 1).stripWhiteSpace()));
650                     pos += (safeHeader.find('"', pos) - pos) + nextDoubleQuotePosition + 1;
651                     // Move past next comma, if there is one
652                     size_t nextCommaPosition2 = safeHeader.find(',', pos);
653                     if (nextCommaPosition2 != notFound)
654                         pos += nextCommaPosition2 - pos + 1;
655                     else
656                         return; // Parse error if there is anything left with no comma
657                 } else {
658                     // Parse error; just use the rest as the value
659                     result.append(std::pair<String, String>(directive, trimToNextSeparator(value.substring(1, value.length() - 1).stripWhiteSpace())));
660                     return;
661                 }
662             } else {
663                 // The value is a token until the next comma
664                 size_t nextCommaPosition2 = value.find(',');
665                 if (nextCommaPosition2 != notFound) {
666                     // The value is delimited by the next comma
667                     result.append(std::pair<String, String>(directive, trimToNextSeparator(value.substring(0, nextCommaPosition2).stripWhiteSpace())));
668                     pos += (safeHeader.find(',', pos) - pos) + 1;
669                 } else {
670                     // The rest is the value; no change to value needed
671                     result.append(std::pair<String, String>(directive, trimToNextSeparator(value)));
672                     return;
673                 }
674             }
675         } else if (nextCommaPosition != notFound && (nextCommaPosition < nextEqualSignPosition || nextEqualSignPosition == notFound)) {
676             // Add directive to map with empty string as value
677             result.append(std::pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, nextCommaPosition - pos).stripWhiteSpace()), ""));
678             pos += nextCommaPosition - pos + 1;
679         } else {
680             // Add last directive to map with empty string as value
681             result.append(std::pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, max - pos).stripWhiteSpace()), ""));
682             return;
683         }
684     }
685 }
686
687 }