Move URL from WebCore to WTF
[WebKit-https.git] / Source / WebCore / platform / network / ResourceRequestBase.cpp
1 /*
2  * Copyright (C) 2003, 2006 Apple Inc.  All rights reserved.
3  * Copyright (C) 2009, 2012 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 #include "config.h"
27 #include "ResourceRequestBase.h"
28
29 #include "HTTPHeaderNames.h"
30 #include "PublicSuffix.h"
31 #include "ResourceRequest.h"
32 #include "ResourceResponse.h"
33 #include "SecurityPolicy.h"
34 #include <wtf/PointerComparison.h>
35
36 namespace WebCore {
37
38 #if PLATFORM(IOS_FAMILY) || USE(CFURLCONNECTION)
39 double ResourceRequestBase::s_defaultTimeoutInterval = INT_MAX;
40 #else
41 // Will use NSURLRequest default timeout unless set to a non-zero value with setDefaultTimeoutInterval().
42 // For libsoup the timeout enabled with integer milliseconds. We set 0 as the default value to avoid integer overflow.
43 double ResourceRequestBase::s_defaultTimeoutInterval = 0;
44 #endif
45
46 inline const ResourceRequest& ResourceRequestBase::asResourceRequest() const
47 {
48     return *static_cast<const ResourceRequest*>(this);
49 }
50
51 ResourceRequest ResourceRequestBase::isolatedCopy() const
52 {
53     ResourceRequest request;
54     request.setAsIsolatedCopy(asResourceRequest());
55     return request;
56 }
57
58 void ResourceRequestBase::setAsIsolatedCopy(const ResourceRequest& other)
59 {
60     setURL(other.url().isolatedCopy());
61     setCachePolicy(other.cachePolicy());
62     setTimeoutInterval(other.timeoutInterval());
63     setFirstPartyForCookies(other.firstPartyForCookies().isolatedCopy());
64     setHTTPMethod(other.httpMethod().isolatedCopy());
65     setPriority(other.priority());
66     setRequester(other.requester());
67     setInitiatorIdentifier(other.initiatorIdentifier().isolatedCopy());
68     setCachePartition(other.cachePartition().isolatedCopy());
69
70     if (auto inspectorInitiatorNodeIdentifier = other.inspectorInitiatorNodeIdentifier())
71         setInspectorInitiatorNodeIdentifier(*inspectorInitiatorNodeIdentifier);
72
73     if (!other.isSameSiteUnspecified()) {
74         setIsSameSite(other.isSameSite());
75         setIsTopSite(other.isTopSite());
76     }
77
78     updateResourceRequest();
79     m_httpHeaderFields = other.httpHeaderFields().isolatedCopy();
80
81     size_t encodingCount = other.m_responseContentDispositionEncodingFallbackArray.size();
82     if (encodingCount > 0) {
83         String encoding1 = other.m_responseContentDispositionEncodingFallbackArray[0].isolatedCopy();
84         String encoding2;
85         String encoding3;
86         if (encodingCount > 1) {
87             encoding2 = other.m_responseContentDispositionEncodingFallbackArray[1].isolatedCopy();
88             if (encodingCount > 2)
89                 encoding3 = other.m_responseContentDispositionEncodingFallbackArray[2].isolatedCopy();
90         }
91         ASSERT(encodingCount <= 3);
92         setResponseContentDispositionEncodingFallbackArray(encoding1, encoding2, encoding3);
93     }
94     if (other.m_httpBody)
95         setHTTPBody(other.m_httpBody->isolatedCopy());
96     setAllowCookies(other.m_allowCookies);
97 }
98
99 bool ResourceRequestBase::isEmpty() const
100 {
101     updateResourceRequest(); 
102     
103     return m_url.isEmpty(); 
104 }
105
106 bool ResourceRequestBase::isNull() const
107 {
108     updateResourceRequest(); 
109     
110     return m_url.isNull();
111 }
112
113 const URL& ResourceRequestBase::url() const 
114 {
115     updateResourceRequest(); 
116     
117     return m_url;
118 }
119
120 void ResourceRequestBase::setURL(const URL& url)
121
122     updateResourceRequest(); 
123
124     m_url = url; 
125     
126     m_platformRequestUpdated = false;
127 }
128
129 static bool shouldUseGet(const ResourceRequestBase& request, const ResourceResponse& redirectResponse)
130 {
131     if (redirectResponse.httpStatusCode() == 301 || redirectResponse.httpStatusCode() == 302)
132         return equalLettersIgnoringASCIICase(request.httpMethod(), "post");
133     return redirectResponse.httpStatusCode() == 303;
134 }
135
136 ResourceRequest ResourceRequestBase::redirectedRequest(const ResourceResponse& redirectResponse, bool shouldClearReferrerOnHTTPSToHTTPRedirect) const
137 {
138     ASSERT(redirectResponse.isRedirection());
139     // This method is based on https://fetch.spec.whatwg.org/#http-redirect-fetch.
140     // It also implements additional processing like done by CFNetwork layer.
141
142     auto request = asResourceRequest();
143     auto location = redirectResponse.httpHeaderField(HTTPHeaderName::Location);
144
145     request.setURL(location.isEmpty() ? URL { } : URL { redirectResponse.url(), location });
146
147     if (shouldUseGet(*this, redirectResponse)) {
148         request.setHTTPMethod("GET"_s);
149         request.setHTTPBody(nullptr);
150         request.clearHTTPContentType();
151         request.m_httpHeaderFields.remove(HTTPHeaderName::ContentLength);
152     }
153
154     if (shouldClearReferrerOnHTTPSToHTTPRedirect && !request.url().protocolIs("https") && WTF::protocolIs(request.httpReferrer(), "https"))
155         request.clearHTTPReferrer();
156
157     if (!protocolHostAndPortAreEqual(request.url(), redirectResponse.url()))
158         request.clearHTTPOrigin();
159     request.clearHTTPAuthorization();
160     request.m_httpHeaderFields.remove(HTTPHeaderName::ProxyAuthorization);
161
162     return request;
163 }
164
165 void ResourceRequestBase::removeCredentials()
166 {
167     updateResourceRequest(); 
168
169     if (m_url.user().isEmpty() && m_url.pass().isEmpty())
170         return;
171
172     m_url.setUser(String());
173     m_url.setPass(String());
174
175     m_platformRequestUpdated = false;
176 }
177
178 ResourceRequestCachePolicy ResourceRequestBase::cachePolicy() const
179 {
180     updateResourceRequest(); 
181     
182     return m_cachePolicy;
183 }
184
185 void ResourceRequestBase::setCachePolicy(ResourceRequestCachePolicy cachePolicy)
186 {
187     updateResourceRequest(); 
188
189     if (m_cachePolicy == cachePolicy)
190         return;
191     
192     m_cachePolicy = cachePolicy;
193     
194     m_platformRequestUpdated = false;
195 }
196
197 double ResourceRequestBase::timeoutInterval() const
198 {
199     updateResourceRequest(); 
200     
201     return m_timeoutInterval; 
202 }
203
204 void ResourceRequestBase::setTimeoutInterval(double timeoutInterval) 
205 {
206     updateResourceRequest(); 
207     
208     if (m_timeoutInterval == timeoutInterval)
209         return;
210
211     m_timeoutInterval = timeoutInterval;
212     
213     m_platformRequestUpdated = false;
214 }
215
216 const URL& ResourceRequestBase::firstPartyForCookies() const
217 {
218     updateResourceRequest(); 
219     
220     return m_firstPartyForCookies;
221 }
222
223 void ResourceRequestBase::setFirstPartyForCookies(const URL& firstPartyForCookies)
224
225     updateResourceRequest(); 
226
227     if (m_firstPartyForCookies == firstPartyForCookies)
228         return;
229
230     m_firstPartyForCookies = firstPartyForCookies;
231     
232     m_platformRequestUpdated = false;
233 }
234
235 bool ResourceRequestBase::isSameSite() const
236 {
237     updateResourceRequest();
238
239     return m_sameSiteDisposition == SameSiteDisposition::SameSite;
240 }
241
242 void ResourceRequestBase::setIsSameSite(bool isSameSite)
243 {
244     updateResourceRequest();
245
246     SameSiteDisposition newDisposition = isSameSite ? SameSiteDisposition::SameSite : SameSiteDisposition::CrossSite;
247     if (m_sameSiteDisposition == newDisposition)
248         return;
249
250     m_sameSiteDisposition = newDisposition;
251
252     m_platformRequestUpdated = false;
253 }
254
255 bool ResourceRequestBase::isTopSite() const
256 {
257     updateResourceRequest();
258
259     return m_isTopSite;
260 }
261
262 void ResourceRequestBase::setIsTopSite(bool isTopSite)
263 {
264     updateResourceRequest();
265
266     if (m_isTopSite == isTopSite)
267         return;
268
269     m_isTopSite = isTopSite;
270
271     m_platformRequestUpdated = false;
272 }
273
274 const String& ResourceRequestBase::httpMethod() const
275 {
276     updateResourceRequest(); 
277     
278     return m_httpMethod; 
279 }
280
281 void ResourceRequestBase::setHTTPMethod(const String& httpMethod) 
282 {
283     updateResourceRequest(); 
284
285     if (m_httpMethod == httpMethod)
286         return;
287
288     m_httpMethod = httpMethod;
289     
290     m_platformRequestUpdated = false;
291 }
292
293 const HTTPHeaderMap& ResourceRequestBase::httpHeaderFields() const
294 {
295     updateResourceRequest(); 
296
297     return m_httpHeaderFields; 
298 }
299
300 String ResourceRequestBase::httpHeaderField(const String& name) const
301 {
302     updateResourceRequest(); 
303     
304     return m_httpHeaderFields.get(name);
305 }
306
307 String ResourceRequestBase::httpHeaderField(HTTPHeaderName name) const
308 {
309     updateResourceRequest(); 
310     
311     return m_httpHeaderFields.get(name);
312 }
313
314 void ResourceRequestBase::setHTTPHeaderField(const String& name, const String& value)
315 {
316     updateResourceRequest();
317
318     m_httpHeaderFields.set(name, value);
319     
320     m_platformRequestUpdated = false;
321 }
322
323 void ResourceRequestBase::setHTTPHeaderField(HTTPHeaderName name, const String& value)
324 {
325     updateResourceRequest();
326
327     m_httpHeaderFields.set(name, value);
328
329     m_platformRequestUpdated = false;
330 }
331
332 void ResourceRequestBase::clearHTTPAuthorization()
333 {
334     updateResourceRequest(); 
335
336     if (!m_httpHeaderFields.remove(HTTPHeaderName::Authorization))
337         return;
338
339     m_platformRequestUpdated = false;
340 }
341
342 String ResourceRequestBase::httpContentType() const
343 {
344     return httpHeaderField(HTTPHeaderName::ContentType);
345 }
346
347 void ResourceRequestBase::setHTTPContentType(const String& httpContentType)
348 {
349     setHTTPHeaderField(HTTPHeaderName::ContentType, httpContentType);
350 }
351
352 void ResourceRequestBase::clearHTTPContentType()
353 {
354     updateResourceRequest(); 
355
356     m_httpHeaderFields.remove(HTTPHeaderName::ContentType);
357
358     m_platformRequestUpdated = false;
359 }
360
361 String ResourceRequestBase::httpReferrer() const
362 {
363     return httpHeaderField(HTTPHeaderName::Referer);
364 }
365
366 bool ResourceRequestBase::hasHTTPReferrer() const
367 {
368     return m_httpHeaderFields.contains(HTTPHeaderName::Referer);
369 }
370
371 void ResourceRequestBase::setHTTPReferrer(const String& httpReferrer)
372 {
373     setHTTPHeaderField(HTTPHeaderName::Referer, httpReferrer);
374 }
375
376 void ResourceRequestBase::setExistingHTTPReferrerToOriginString()
377 {
378     if (!hasHTTPReferrer())
379         return;
380
381     setHTTPHeaderField(HTTPHeaderName::Referer, SecurityPolicy::referrerToOriginString(httpReferrer()));
382 }
383     
384 void ResourceRequestBase::clearHTTPReferrer()
385 {
386     updateResourceRequest(); 
387
388     m_httpHeaderFields.remove(HTTPHeaderName::Referer);
389
390     m_platformRequestUpdated = false;
391 }
392
393 String ResourceRequestBase::httpOrigin() const
394 {
395     return httpHeaderField(HTTPHeaderName::Origin);
396 }
397
398 void ResourceRequestBase::setHTTPOrigin(const String& httpOrigin)
399 {
400     setHTTPHeaderField(HTTPHeaderName::Origin, httpOrigin);
401 }
402
403 bool ResourceRequestBase::hasHTTPOrigin() const
404 {
405     return m_httpHeaderFields.contains(HTTPHeaderName::Origin);
406 }
407
408 void ResourceRequestBase::clearHTTPOrigin()
409 {
410     updateResourceRequest();
411
412     m_httpHeaderFields.remove(HTTPHeaderName::Origin);
413
414     m_platformRequestUpdated = false;
415 }
416
417 bool ResourceRequestBase::hasHTTPHeader(HTTPHeaderName name) const
418 {
419     return m_httpHeaderFields.contains(name);
420 }
421
422 String ResourceRequestBase::httpUserAgent() const
423 {
424     return httpHeaderField(HTTPHeaderName::UserAgent);
425 }
426
427 void ResourceRequestBase::setHTTPUserAgent(const String& httpUserAgent)
428 {
429     setHTTPHeaderField(HTTPHeaderName::UserAgent, httpUserAgent);
430 }
431
432 void ResourceRequestBase::clearHTTPUserAgent()
433 {
434     updateResourceRequest(); 
435
436     m_httpHeaderFields.remove(HTTPHeaderName::UserAgent);
437
438     m_platformRequestUpdated = false;
439 }
440
441 String ResourceRequestBase::httpAccept() const
442 {
443     return httpHeaderField(HTTPHeaderName::Accept);
444 }
445
446 void ResourceRequestBase::setHTTPAccept(const String& httpAccept)
447 {
448     setHTTPHeaderField(HTTPHeaderName::Accept, httpAccept);
449 }
450
451 void ResourceRequestBase::clearHTTPAccept()
452 {
453     updateResourceRequest(); 
454
455     m_httpHeaderFields.remove(HTTPHeaderName::Accept);
456
457     m_platformRequestUpdated = false;
458 }
459
460 void ResourceRequestBase::clearHTTPAcceptEncoding()
461 {
462     updateResourceRequest();
463
464     m_httpHeaderFields.remove(HTTPHeaderName::AcceptEncoding);
465
466     m_platformRequestUpdated = false;
467 }
468
469 void ResourceRequestBase::setResponseContentDispositionEncodingFallbackArray(const String& encoding1, const String& encoding2, const String& encoding3)
470 {
471     updateResourceRequest(); 
472     
473     m_responseContentDispositionEncodingFallbackArray.clear();
474     m_responseContentDispositionEncodingFallbackArray.reserveInitialCapacity(!encoding1.isNull() + !encoding2.isNull() + !encoding3.isNull());
475     if (!encoding1.isNull())
476         m_responseContentDispositionEncodingFallbackArray.uncheckedAppend(encoding1);
477     if (!encoding2.isNull())
478         m_responseContentDispositionEncodingFallbackArray.uncheckedAppend(encoding2);
479     if (!encoding3.isNull())
480         m_responseContentDispositionEncodingFallbackArray.uncheckedAppend(encoding3);
481     
482     m_platformRequestUpdated = false;
483 }
484
485 FormData* ResourceRequestBase::httpBody() const
486 {
487     updateResourceRequest(HTTPBodyUpdatePolicy::UpdateHTTPBody);
488
489     return m_httpBody.get();
490 }
491
492 void ResourceRequestBase::setHTTPBody(RefPtr<FormData>&& httpBody)
493 {
494     updateResourceRequest();
495
496     m_httpBody = WTFMove(httpBody);
497
498     m_resourceRequestBodyUpdated = true;
499
500     m_platformRequestBodyUpdated = false;
501 }
502
503 bool ResourceRequestBase::allowCookies() const
504 {
505     updateResourceRequest(); 
506     
507     return m_allowCookies;
508 }
509
510 void ResourceRequestBase::setAllowCookies(bool allowCookies)
511 {
512     updateResourceRequest(); 
513
514     if (m_allowCookies == allowCookies)
515         return;
516
517     m_allowCookies = allowCookies;
518     
519     m_platformRequestUpdated = false;
520 }
521
522 ResourceLoadPriority ResourceRequestBase::priority() const
523 {
524     updateResourceRequest();
525
526     return m_priority;
527 }
528
529 void ResourceRequestBase::setPriority(ResourceLoadPriority priority)
530 {
531     updateResourceRequest();
532
533     if (m_priority == priority)
534         return;
535
536     m_priority = priority;
537
538     m_platformRequestUpdated = false;
539 }
540
541 void ResourceRequestBase::addHTTPHeaderFieldIfNotPresent(HTTPHeaderName name, const String& value)
542 {
543     updateResourceRequest();
544
545     if (!m_httpHeaderFields.addIfNotPresent(name, value))
546         return;
547
548     m_platformRequestUpdated = false;
549 }
550
551 void ResourceRequestBase::addHTTPHeaderField(HTTPHeaderName name, const String& value)
552 {
553     updateResourceRequest();
554
555     m_httpHeaderFields.add(name, value);
556
557     m_platformRequestUpdated = false;
558 }
559
560 void ResourceRequestBase::addHTTPHeaderField(const String& name, const String& value)
561 {
562     updateResourceRequest();
563
564     m_httpHeaderFields.add(name, value);
565
566     m_platformRequestUpdated = false;
567 }
568
569 bool ResourceRequestBase::hasHTTPHeaderField(HTTPHeaderName headerName) const
570 {
571     return m_httpHeaderFields.contains(headerName);
572 }
573
574 void ResourceRequestBase::setHTTPHeaderFields(HTTPHeaderMap headerFields)
575 {
576     updateResourceRequest();
577
578     m_httpHeaderFields = WTFMove(headerFields);
579
580     m_platformRequestUpdated = false;
581 }
582
583 #if USE(SYSTEM_PREVIEW)
584 bool ResourceRequestBase::isSystemPreview() const
585 {
586     return m_isSystemPreview;
587 }
588
589 void ResourceRequestBase::setSystemPreview(bool s)
590 {
591     m_isSystemPreview = s;
592 }
593
594 const IntRect& ResourceRequestBase::systemPreviewRect() const
595 {
596     return m_systemPreviewRect;
597 }
598
599 void ResourceRequestBase::setSystemPreviewRect(const IntRect& rect)
600 {
601     m_systemPreviewRect = rect;
602 }
603 #endif
604
605 bool equalIgnoringHeaderFields(const ResourceRequestBase& a, const ResourceRequestBase& b)
606 {
607     if (a.url() != b.url())
608         return false;
609     
610     if (a.cachePolicy() != b.cachePolicy())
611         return false;
612     
613     if (a.timeoutInterval() != b.timeoutInterval())
614         return false;
615     
616     if (a.firstPartyForCookies() != b.firstPartyForCookies())
617         return false;
618
619     if (a.isSameSite() != b.isSameSite())
620         return false;
621
622     if (a.isTopSite() != b.isTopSite())
623         return false;
624     
625     if (a.httpMethod() != b.httpMethod())
626         return false;
627     
628     if (a.allowCookies() != b.allowCookies())
629         return false;
630     
631     if (a.priority() != b.priority())
632         return false;
633
634     if (a.requester() != b.requester())
635         return false;
636
637     return arePointingToEqualData(a.httpBody(), b.httpBody());
638 }
639
640 bool ResourceRequestBase::equal(const ResourceRequest& a, const ResourceRequest& b)
641 {
642     if (!equalIgnoringHeaderFields(a, b))
643         return false;
644     
645     if (a.httpHeaderFields() != b.httpHeaderFields())
646         return false;
647         
648     return ResourceRequest::platformCompare(a, b);
649 }
650
651 static const HTTPHeaderName conditionalHeaderNames[] = {
652     HTTPHeaderName::IfMatch,
653     HTTPHeaderName::IfModifiedSince,
654     HTTPHeaderName::IfNoneMatch,
655     HTTPHeaderName::IfRange,
656     HTTPHeaderName::IfUnmodifiedSince
657 };
658
659 bool ResourceRequestBase::isConditional() const
660 {
661     updateResourceRequest();
662
663     for (auto headerName : conditionalHeaderNames) {
664         if (m_httpHeaderFields.contains(headerName))
665             return true;
666     }
667
668     return false;
669 }
670
671 void ResourceRequestBase::makeUnconditional()
672 {
673     updateResourceRequest();
674
675     for (auto headerName : conditionalHeaderNames)
676         m_httpHeaderFields.remove(headerName);
677 }
678
679 double ResourceRequestBase::defaultTimeoutInterval()
680 {
681     return s_defaultTimeoutInterval;
682 }
683
684 void ResourceRequestBase::setDefaultTimeoutInterval(double timeoutInterval)
685 {
686     s_defaultTimeoutInterval = timeoutInterval;
687 }
688
689 void ResourceRequestBase::updatePlatformRequest(HTTPBodyUpdatePolicy bodyPolicy) const
690 {
691     if (!m_platformRequestUpdated) {
692         ASSERT(m_resourceRequestUpdated);
693         const_cast<ResourceRequest&>(asResourceRequest()).doUpdatePlatformRequest();
694         m_platformRequestUpdated = true;
695     }
696
697     if (!m_platformRequestBodyUpdated && bodyPolicy == HTTPBodyUpdatePolicy::UpdateHTTPBody) {
698         ASSERT(m_resourceRequestBodyUpdated);
699         const_cast<ResourceRequest&>(asResourceRequest()).doUpdatePlatformHTTPBody();
700         m_platformRequestBodyUpdated = true;
701     }
702 }
703
704 void ResourceRequestBase::updateResourceRequest(HTTPBodyUpdatePolicy bodyPolicy) const
705 {
706     if (!m_resourceRequestUpdated) {
707         ASSERT(m_platformRequestUpdated);
708         const_cast<ResourceRequest&>(asResourceRequest()).doUpdateResourceRequest();
709         m_resourceRequestUpdated = true;
710     }
711
712     if (!m_resourceRequestBodyUpdated && bodyPolicy == HTTPBodyUpdatePolicy::UpdateHTTPBody) {
713         ASSERT(m_platformRequestBodyUpdated);
714         const_cast<ResourceRequest&>(asResourceRequest()).doUpdateResourceHTTPBody();
715         m_resourceRequestBodyUpdated = true;
716     }
717 }
718
719 #if !PLATFORM(COCOA) && !USE(CFURLCONNECTION) && !USE(SOUP)
720 unsigned initializeMaximumHTTPConnectionCountPerHost()
721 {
722     // This is used by the loader to control the number of issued parallel load requests. 
723     // Four seems to be a common default in HTTP frameworks.
724     return 4;
725 }
726 #endif
727
728 void ResourceRequestBase::setCachePartition(const String& cachePartition)
729 {
730 #if ENABLE(CACHE_PARTITIONING)
731     ASSERT(!cachePartition.isNull());
732     ASSERT(cachePartition == partitionName(cachePartition));
733     m_cachePartition = cachePartition;
734 #else
735     UNUSED_PARAM(cachePartition);
736 #endif
737 }
738
739 String ResourceRequestBase::partitionName(const String& domain)
740 {
741 #if ENABLE(PUBLIC_SUFFIX_LIST)
742     if (domain.isNull())
743         return emptyString();
744     String highLevel = topPrivatelyControlledDomain(domain);
745     if (highLevel.isNull())
746         return emptyString();
747     return highLevel;
748 #else
749     UNUSED_PARAM(domain);
750 #if ENABLE(CACHE_PARTITIONING)
751 #error Cache partitioning requires PUBLIC_SUFFIX_LIST
752 #endif
753     return emptyString();
754 #endif
755 }
756
757 }