1 // Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights 2 // reserved. Use of this source code is governed by a BSD-style license that 3 // can be found in the LICENSE file. 4 5 #ifndef CEF_LIBCEF_COMMON_REQUEST_IMPL_H_ 6 #define CEF_LIBCEF_COMMON_REQUEST_IMPL_H_ 7 #pragma once 8 9 #include <stdint.h> 10 11 #include <memory> 12 13 #include "include/cef_request.h" 14 15 #include "base/synchronization/lock.h" 16 #include "net/cookies/site_for_cookies.h" 17 #include "services/network/public/mojom/referrer_policy.mojom-shared.h" 18 #include "url/gurl.h" 19 20 namespace blink { 21 class WebURLRequest; 22 } // namespace blink 23 24 namespace navigation_interception { 25 class NavigationParams; 26 } 27 28 namespace net { 29 class HttpRequestHeaders; 30 struct RedirectInfo; 31 class UploadData; 32 class UploadDataStream; 33 class UploadElement; 34 class UploadElementReader; 35 } // namespace net 36 37 namespace network { 38 class DataElement; 39 struct ResourceRequest; 40 class ResourceRequestBody; 41 } // namespace network 42 43 struct CefMsg_LoadRequest_Params; 44 struct CefNavigateParams; 45 46 // Implementation of CefRequest 47 class CefRequestImpl : public CefRequest { 48 public: 49 enum Changes { 50 kChangedNone = 0, 51 kChangedUrl = 1 << 0, 52 kChangedMethod = 1 << 1, 53 kChangedReferrer = 1 << 2, 54 kChangedPostData = 1 << 3, 55 kChangedHeaderMap = 1 << 4, 56 kChangedFlags = 1 << 5, 57 kChangedSiteForCookies = 1 << 6, 58 }; 59 60 CefRequestImpl(); 61 62 bool IsReadOnly() override; 63 CefString GetURL() override; 64 void SetURL(const CefString& url) override; 65 CefString GetMethod() override; 66 void SetMethod(const CefString& method) override; 67 void SetReferrer(const CefString& referrer_url, 68 ReferrerPolicy policy) override; 69 CefString GetReferrerURL() override; 70 ReferrerPolicy GetReferrerPolicy() override; 71 CefRefPtr<CefPostData> GetPostData() override; 72 void SetPostData(CefRefPtr<CefPostData> postData) override; 73 void GetHeaderMap(HeaderMap& headerMap) override; 74 void SetHeaderMap(const HeaderMap& headerMap) override; 75 CefString GetHeaderByName(const CefString& name) override; 76 void SetHeaderByName(const CefString& name, 77 const CefString& value, 78 bool overwrite) override; 79 void Set(const CefString& url, 80 const CefString& method, 81 CefRefPtr<CefPostData> postData, 82 const HeaderMap& headerMap) override; 83 int GetFlags() override; 84 void SetFlags(int flags) override; 85 CefString GetFirstPartyForCookies() override; 86 void SetFirstPartyForCookies(const CefString& url) override; 87 ResourceType GetResourceType() override; 88 TransitionType GetTransitionType() override; 89 uint64 GetIdentifier() override; 90 91 // Populate this object from the ResourceRequest object. 92 void Set(const network::ResourceRequest* request, uint64 identifier); 93 94 // Populate the ResourceRequest object from this object. 95 // If |changed_only| is true then only the changed fields will be updated. 96 void Get(network::ResourceRequest* request, bool changed_only) const; 97 98 // Populate this object from the RedirectInfo object. 99 void Set(const net::RedirectInfo& redirect_info); 100 101 // Populate this object from teh HttpRequestHeaders object. 102 void Set(const net::HttpRequestHeaders& headers); 103 104 // Populate this object from the NavigationParams object. 105 // TODO(cef): Remove the |is_main_frame| argument once NavigationParams is 106 // reliable in reporting that value. 107 // Called from content_browser_client.cc NavigationOnUIThread(). 108 void Set(const navigation_interception::NavigationParams& params, 109 bool is_main_frame); 110 111 // Populate the WebURLRequest object based on the contents of |params|. 112 // Called from CefBrowserImpl::LoadRequest(). 113 static void Get(const CefMsg_LoadRequest_Params& params, 114 blink::WebURLRequest& request); 115 116 // Populate the CefNavigateParams object from this object. 117 // Called from CefFrameHostImpl::LoadRequest(). 118 void Get(CefNavigateParams& params) const; 119 120 void SetReadOnly(bool read_only); 121 122 // Enable or disable tracking of changes. If |track_changes| is true the 123 // status of changes will be tracked, and retrievable via GetChanges(). If 124 // |backup_on_change| is true the original value will be backed up before the 125 // first change. The original values can later be restored by calling 126 // RevertChanges() before calling SetTrackChanges(false). 127 void SetTrackChanges(bool track_changes, bool backup_on_change = false); 128 void RevertChanges(); 129 void DiscardChanges(); 130 uint8_t GetChanges() const; 131 132 static network::mojom::ReferrerPolicy NetReferrerPolicyToBlinkReferrerPolicy( 133 cef_referrer_policy_t net_policy); 134 static cef_referrer_policy_t BlinkReferrerPolicyToNetReferrerPolicy( 135 network::mojom::ReferrerPolicy blink_policy); 136 137 private: 138 // Mark values as changed. Must be called before the new values are assigned. 139 void Changed(uint8_t changes); 140 141 // Used with the Set() methods that export data to other object types. Returns 142 // true if the values should be set on the export object. If |changed_only| is 143 // true then only return true if the value has been changed in combination 144 // with track changes. 145 bool ShouldSet(uint8_t changes, bool changed_only) const; 146 147 void Reset(); 148 149 GURL url_; 150 std::string method_; 151 GURL referrer_url_; 152 ReferrerPolicy referrer_policy_; 153 CefRefPtr<CefPostData> postdata_; 154 HeaderMap headermap_; 155 ResourceType resource_type_; 156 TransitionType transition_type_; 157 uint64 identifier_; 158 159 // The below members are used by CefURLRequest. 160 int flags_; 161 net::SiteForCookies site_for_cookies_; 162 163 // Stores backup of values for use with track changes. 164 struct Backup { 165 // Bitmask of values that have been backed up. 166 uint8_t backups_ = kChangedNone; 167 168 GURL url_; 169 std::string method_; 170 GURL referrer_url_; 171 ReferrerPolicy referrer_policy_; 172 CefRefPtr<CefPostData> postdata_; 173 std::unique_ptr<HeaderMap> headermap_; 174 int flags_; 175 net::SiteForCookies site_for_cookies_; 176 }; 177 std::unique_ptr<Backup> backup_; 178 179 // True if this object is read-only. 180 bool read_only_ = false; 181 182 // True if this object should track changes. 183 bool track_changes_ = false; 184 185 // True if original values should be backed up when |track_changes_| is true. 186 bool backup_on_change_ = false; 187 188 // Bitmask of |Changes| values which indicate which fields have changed. 189 uint8_t changes_ = kChangedNone; 190 191 mutable base::Lock lock_; 192 193 IMPLEMENT_REFCOUNTING(CefRequestImpl); 194 }; 195 196 // Implementation of CefPostData 197 class CefPostDataImpl : public CefPostData { 198 public: 199 CefPostDataImpl(); 200 201 bool IsReadOnly() override; 202 bool HasExcludedElements() override; 203 size_t GetElementCount() override; 204 void GetElements(ElementVector& elements) override; 205 bool RemoveElement(CefRefPtr<CefPostDataElement> element) override; 206 bool AddElement(CefRefPtr<CefPostDataElement> element) override; 207 void RemoveElements() override; 208 209 void Set(const network::ResourceRequestBody& body); 210 scoped_refptr<network::ResourceRequestBody> GetBody() const; 211 void Set(const net::UploadData& data); 212 void Set(const net::UploadDataStream& data_stream); 213 void Get(net::UploadData& data) const; 214 std::unique_ptr<net::UploadDataStream> Get() const; 215 216 void SetReadOnly(bool read_only); 217 218 void SetTrackChanges(bool track_changes); 219 bool HasChanges() const; 220 221 private: 222 void Changed(); 223 224 ElementVector elements_; 225 226 // True if this object is read-only. 227 bool read_only_; 228 229 // True if this object has excluded elements. 230 bool has_excluded_elements_; 231 232 // True if this object should track changes. 233 bool track_changes_; 234 235 // True if this object has changes. 236 bool has_changes_; 237 238 mutable base::Lock lock_; 239 240 IMPLEMENT_REFCOUNTING(CefPostDataImpl); 241 }; 242 243 // Implementation of CefPostDataElement 244 class CefPostDataElementImpl : public CefPostDataElement { 245 public: 246 CefPostDataElementImpl(); 247 ~CefPostDataElementImpl() override; 248 249 bool IsReadOnly() override; 250 void SetToEmpty() override; 251 void SetToFile(const CefString& fileName) override; 252 void SetToBytes(size_t size, const void* bytes) override; 253 Type GetType() override; 254 CefString GetFile() override; 255 size_t GetBytesCount() override; 256 size_t GetBytes(size_t size, void* bytes) override; 257 GetBytes()258 void* GetBytes() { return data_.bytes.bytes; } 259 260 void Set(const network::DataElement& element); 261 void Get(network::ResourceRequestBody& body) const; 262 void Set(const net::UploadElement& element); 263 void Set(const net::UploadElementReader& element_reader); 264 void Get(net::UploadElement& element) const; 265 std::unique_ptr<net::UploadElementReader> Get() const; 266 267 void SetReadOnly(bool read_only); 268 269 void SetTrackChanges(bool track_changes); 270 bool HasChanges() const; 271 272 private: 273 void Changed(); 274 void Cleanup(); 275 276 Type type_; 277 union { 278 struct { 279 void* bytes; 280 size_t size; 281 } bytes; 282 cef_string_t filename; 283 } data_; 284 285 // True if this object is read-only. 286 bool read_only_; 287 288 // True if this object should track changes. 289 bool track_changes_; 290 291 // True if this object has changes. 292 bool has_changes_; 293 294 mutable base::Lock lock_; 295 296 IMPLEMENT_REFCOUNTING(CefPostDataElementImpl); 297 }; 298 299 #endif // CEF_LIBCEF_COMMON_REQUEST_IMPL_H_ 300