1 /* 2 * Copyright (C) 2009 Google Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above 11 * copyright notice, this list of conditions and the following disclaimer 12 * in the documentation and/or other materials provided with the 13 * distribution. 14 * * Neither the name of Google Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived from 16 * this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #ifndef ThreadableLoader_h 32 #define ThreadableLoader_h 33 34 #include "core/fetch/ResourceLoaderOptions.h" 35 #include "platform/CrossThreadCopier.h" 36 #include "wtf/Noncopyable.h" 37 #include "wtf/PassRefPtr.h" 38 #include "wtf/RefCounted.h" 39 #include "wtf/RefPtr.h" 40 41 namespace blink { 42 43 class ResourceRequest; 44 class ExecutionContext; 45 class ThreadableLoaderClient; 46 47 enum CrossOriginRequestPolicy { 48 DenyCrossOriginRequests, 49 UseAccessControl, 50 AllowCrossOriginRequests 51 }; 52 53 enum PreflightPolicy { 54 ConsiderPreflight, 55 ForcePreflight, 56 PreventPreflight 57 }; 58 59 enum ContentSecurityPolicyEnforcement { 60 EnforceConnectSrcDirective, 61 DoNotEnforceContentSecurityPolicy, 62 }; 63 64 struct ThreadableLoaderOptions { ThreadableLoaderOptionsThreadableLoaderOptions65 ThreadableLoaderOptions() 66 : preflightPolicy(ConsiderPreflight) 67 , crossOriginRequestPolicy(DenyCrossOriginRequests) 68 , contentSecurityPolicyEnforcement(EnforceConnectSrcDirective) 69 , timeoutMilliseconds(0) { } 70 71 // When adding members, CrossThreadThreadableLoaderOptionsData should 72 // be updated. 73 PreflightPolicy preflightPolicy; // If AccessControl is used, how to determine if a preflight is needed. 74 CrossOriginRequestPolicy crossOriginRequestPolicy; 75 AtomicString initiator; 76 ContentSecurityPolicyEnforcement contentSecurityPolicyEnforcement; 77 unsigned long timeoutMilliseconds; 78 }; 79 80 // Encode AtomicString as String to cross threads. 81 struct CrossThreadThreadableLoaderOptionsData { CrossThreadThreadableLoaderOptionsDataCrossThreadThreadableLoaderOptionsData82 explicit CrossThreadThreadableLoaderOptionsData(const ThreadableLoaderOptions& options) 83 : preflightPolicy(options.preflightPolicy) 84 , crossOriginRequestPolicy(options.crossOriginRequestPolicy) 85 , initiator(options.initiator.string().isolatedCopy()) 86 , contentSecurityPolicyEnforcement(options.contentSecurityPolicyEnforcement) 87 , timeoutMilliseconds(options.timeoutMilliseconds) { } 88 ThreadableLoaderOptionsCrossThreadThreadableLoaderOptionsData89 operator ThreadableLoaderOptions() const 90 { 91 ThreadableLoaderOptions options; 92 options.preflightPolicy = preflightPolicy; 93 options.crossOriginRequestPolicy = crossOriginRequestPolicy; 94 options.initiator = AtomicString(initiator); 95 options.contentSecurityPolicyEnforcement = contentSecurityPolicyEnforcement; 96 options.timeoutMilliseconds = timeoutMilliseconds; 97 return options; 98 } 99 100 PreflightPolicy preflightPolicy; 101 CrossOriginRequestPolicy crossOriginRequestPolicy; 102 String initiator; 103 ContentSecurityPolicyEnforcement contentSecurityPolicyEnforcement; 104 unsigned long timeoutMilliseconds; 105 }; 106 107 template<> struct CrossThreadCopierBase<false, false, false, ThreadableLoaderOptions> { 108 typedef CrossThreadThreadableLoaderOptionsData Type; 109 static Type copy(const ThreadableLoaderOptions& options) 110 { 111 return CrossThreadThreadableLoaderOptionsData(options); 112 } 113 }; 114 115 // Useful for doing loader operations from any thread (not threadsafe, 116 // just able to run on threads other than the main thread). 117 class ThreadableLoader : public RefCounted<ThreadableLoader> { 118 WTF_MAKE_NONCOPYABLE(ThreadableLoader); 119 public: 120 // ThreadableLoaderOptions argument configures this ThreadableLoader's 121 // behavior. 122 // 123 // ResourceLoaderOptions argument will be passed to the FetchRequest 124 // that this ThreadableLoader creates. It can be altered e.g. when 125 // redirect happens. 126 static void loadResourceSynchronously(ExecutionContext&, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&, const ResourceLoaderOptions&); 127 static PassRefPtr<ThreadableLoader> create(ExecutionContext&, ThreadableLoaderClient*, const ResourceRequest&, const ThreadableLoaderOptions&, const ResourceLoaderOptions&); 128 129 // A ThreadableLoader may have a timeout specified. It is possible, in some cases, for 130 // the timeout to be overridden after the request is sent (for example, XMLHttpRequests 131 // may override their timeout setting after sending). 132 // 133 // Set a new timeout relative to the time the request started, in milliseconds. 134 virtual void overrideTimeout(unsigned long timeoutMilliseconds) = 0; 135 136 virtual void cancel() = 0; 137 138 virtual ~ThreadableLoader() { } 139 140 protected: 141 ThreadableLoader() { } 142 }; 143 144 } // namespace blink 145 146 #endif // ThreadableLoader_h 147