| // Copyright 2017 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef CONTENT_PUBLIC_TEST_TEST_DOWNLOAD_HTTP_RESPONSE_H_ |
| #define CONTENT_PUBLIC_TEST_TEST_DOWNLOAD_HTTP_RESPONSE_H_ |
| |
| #include <string> |
| #include <vector> |
| |
| #include "base/callback_forward.h" |
| #include "base/containers/queue.h" |
| #include "base/sequence_checker.h" |
| #include "net/http/http_byte_range.h" |
| #include "net/http/http_response_info.h" |
| #include "net/test/embedded_test_server/embedded_test_server.h" |
| #include "net/test/embedded_test_server/http_request.h" |
| #include "net/test/embedded_test_server/http_response.h" |
| #include "third_party/abseil-cpp/absl/types/optional.h" |
| |
| namespace net { |
| class HttpByteRange; |
| } // namespace net |
| |
| namespace content { |
| |
| // Class for configuring and returning http responses for download requests. |
| // Each instance can handle one http request. |
| // Lives on embedded test server's IO thread. |
| class TestDownloadHttpResponse { |
| public: |
| static const char kTestDownloadHostName[]; |
| static GURL GetNextURLForDownload(); |
| |
| // OnPauseHandler can be used to pause the response until the enclosed |
| // callback is called. The OnPauseHandler is copyable for Parameters |
| // objects to be used repeatedly, though it will only be called once when |
| // given to a TestDownloadHttpResponse. |
| using OnPauseHandler = base::RepeatingCallback<void(base::OnceClosure)>; |
| |
| // Called when an injected error triggers. |
| using InjectErrorCallback = base::RepeatingCallback<void(int64_t, int64_t)>; |
| |
| struct HttpResponseData { |
| HttpResponseData() = default; |
| HttpResponseData(int64_t min_offset, |
| int64_t max_offset, |
| const std::string& response, |
| bool is_transient, |
| bool delay_response); |
| HttpResponseData(const HttpResponseData& other) = default; |
| HttpResponseData& operator=(const HttpResponseData& other) = default; |
| |
| // The range for first byte position in range header to use this response. |
| int64_t min_offset = -1; |
| int64_t max_offset = -1; |
| |
| std::string response; |
| |
| // Whether the response data is transient and will be invalidated after |
| // sending once. |
| bool is_transient = false; |
| |
| bool delay_response = false; |
| }; |
| |
| struct Parameters { |
| // Constructs a Parameters structure using the default constructor, but with |
| // the injection of an error which will be triggered at byte offset |
| // (filesize / 2). |inject_error_cb| will be called once the response is |
| // sent. |
| static Parameters WithSingleInterruption( |
| const InjectErrorCallback& inject_error_cb); |
| |
| // The default constructor initializes the parameters for serving a 100 KB |
| // resource with no interruptions. The response contains an ETag and a |
| // Last-Modified header and the server supports byte range requests. |
| Parameters(); |
| |
| Parameters(const Parameters&); |
| Parameters& operator=(const Parameters&); |
| |
| ~Parameters(); |
| |
| // Clears the errors in injected_errors. |
| void ClearInjectedErrors(); |
| |
| // Sets the response for range request when the starting offset of |
| // the request falls into [min_offset, max_offset]. If |is_transient| |
| // is true, |response| will only be sent once for the given range. And |
| // later responses will be calculated from the parameters. If |
| // |is_transient| is false, the |response| will be applied to the |
| // given range request forever. |
| // if |delay_response| is true, the response body will be sent when |
| // SendDelayedResponse() is called. |
| void SetResponseForRangeRequest(int64_t min_offset, |
| int64_t max_offset, |
| const std::string& response, |
| bool is_transient = false, |
| bool delay_response = false); |
| |
| // Contents of the ETag header field of the response. No Etag header is |
| // sent if this field is empty. |
| std::string etag; |
| |
| // Contents of the Last-Modified header field of the response. No |
| // Last-Modified header is sent if this field is empty. |
| std::string last_modified; |
| |
| // The Content-Type of the response. No Content-Type header is sent if this |
| // field is empty. |
| std::string content_type; |
| |
| // The total size of the entity body. If the entire entity is requested, |
| // then this would be the same as the value returned in the Content-Length |
| // header. |
| int64_t size; |
| |
| // Seed for the pseudo-random sequence that defines the response body |
| // contents. The seed is with GetPatternBytes() to generate the body of the |
| // response. |
| int pattern_generator_seed; |
| |
| // Whether the server can handle partial request. |
| // If true, contains a 'Accept-Ranges: bytes' header for HTTP 200 |
| // response, or contains 'Content-Range' header for HTTP 206 response. |
| bool support_byte_ranges; |
| |
| // Whether the server supports partial range responses. A server can claim |
| // it support byte ranges, but actually doesn't send partial responses. In |
| // that case, Set |support_byte_ranges| to true and this variable to false |
| // to simulate the case. |
| bool support_partial_response; |
| |
| // The connection type in the response. |
| net::HttpResponseInfo::ConnectionInfo connection_type; |
| |
| // If specified, return this as the http response to the client. |
| // No error injection or range request will be handled for static response. |
| std::string static_response; |
| |
| // List of responses for range requests. |
| std::vector<HttpResponseData> range_request_responses; |
| |
| // Error offsets to be injected. The response will successfully fulfill |
| // requests to read up to offset. An attempt to read the byte at offset |
| // cause |inject_error_cb| to run. |
| // |
| // If a read spans the range containing an offset, then the portion of the |
| // request preceding the offset will succeed. The next read would start at |
| // offset and hence would result in an error. |
| // |
| // E.g.: injected_errors.push(100); |
| // |
| // A network read for 1024 bytes at offset 0 would result in successfully |
| // reading 100 bytes (bytes with offset 0-99). The next read would, |
| // therefore, start at offset 100 and would result in |inject_error_cb| |
| // to get called. |
| // |
| // Injected errors are processed in the order in which they appear in |
| // |injected_errors|. When handling a network request for the range [S,E] |
| // (inclusive), all events in |injected_errors| whose offset is less than |
| // S will be ignored. The first event remaining will trigger an error once |
| // the sequence of reads proceeds to a point where its offset is included |
| // in [S,E]. |
| // |
| // This implies that |injected_errors| must be specified in increasing order |
| // of offset. I.e. |injected_errors| must be sorted by offset. |
| // |
| // Errors at relative offset 0 are ignored for a partial request. I.e. If |
| // the request is for the byte range 100-200, then an error at offset 100 |
| // will not trigger. This is done so that non-overlapping continuation |
| // attempts don't require resetting parameters to succeed. |
| // |
| // E.g.: If the caller injects an error at offset 100, then a request for |
| // the entire entity will fail after reading 100 bytes (offsets 0 through |
| // 99). A subsequent request for byte range "100-" (offsets 100 through EOF) |
| // will succeed since the error at offset 100 is ignored. |
| // |
| // An injected error with -1 offset will immediately abort the response |
| // without sending anything to the client, including the response header. |
| base::queue<int64_t> injected_errors; |
| |
| // Callback to run when an injected error triggers. |
| InjectErrorCallback inject_error_cb; |
| |
| // If on_pause_handler is valid, it will be invoked once when the |
| // |pause_condition| is reached. It is not a OnceCallback to allow |
| // Parameters to be reused. |
| OnPauseHandler on_pause_handler; |
| |
| // Offset of body to pause the response sending. A -1 offset will pause |
| // the response before header is sent. |
| absl::optional<int64_t> pause_offset; |
| }; |
| |
| // Information about completed requests. |
| struct CompletedRequest { |
| CompletedRequest(const net::test_server::HttpRequest& request); |
| ~CompletedRequest(); |
| |
| // Count of bytes returned in the response body. |
| int64_t transferred_byte_count = 0; |
| |
| // The request received from the client. |
| net::test_server::HttpRequest http_request; |
| }; |
| |
| // Called when response are sent to the client. |
| using OnResponseSentCallback = |
| base::OnceCallback<void(std::unique_ptr<CompletedRequest>)>; |
| |
| // Generate a pseudo random pattern. |
| // |
| // |seed| is the seed for the pseudo random sequence. |offset| is the byte |
| // offset into the sequence. |length| is a count of bytes to generate. |
| // |
| // The pattern has the following properties: |
| // |
| // * For a given |seed|, the entire sequence of bytes is fixed. Any |
| // subsequence can be generated by specifying the |offset| and |length|. |
| // |
| // * The sequence is aperiodic (at least for the first 1M bytes). |
| // |
| // * |seed| is chaotic. Different seeds produce "very different" data. This |
| // means that there's no trivial mapping between sequences generated using |
| // two distinct seeds. |
| // |
| // These properties make the generated bytes useful for testing partial |
| // requests where the response may need to be built using a sequence of |
| // partial requests. |
| // |
| // Note: Don't use this function to generate a cryptographically secure |
| // pseudo-random sequence. |
| static std::string GetPatternBytes(int seed, int64_t offset, int length); |
| |
| // Start responding to http request for |url| with responses based on |
| // |parameters|. |
| // |
| // This method registers the |url| and |parameters| mapping until another |
| // call to StartServing() or StartServingStaticResponse() changes it. It |
| // can be called on any thread. |
| static void StartServing( |
| const TestDownloadHttpResponse::Parameters& parameters, |
| const GURL& url); |
| |
| // Start responding to URLRequests for |url| with a static response |
| // containing the headers in |headers|. |
| static void StartServingStaticResponse(const std::string& headers, |
| const GURL& url); |
| |
| TestDownloadHttpResponse(const net::test_server::HttpRequest& request, |
| const Parameters& parameters, |
| OnResponseSentCallback on_response_sent_callback); |
| |
| TestDownloadHttpResponse(const TestDownloadHttpResponse&) = delete; |
| TestDownloadHttpResponse& operator=(const TestDownloadHttpResponse&) = delete; |
| |
| ~TestDownloadHttpResponse(); |
| |
| // Creates a shim HttpResponse object for embedded test server. This life time |
| // of the object returned is short. |
| std::unique_ptr<net::test_server::HttpResponse> CreateResponseForTestServer(); |
| |
| // Starts to send the response. |delegate| owns the shim HttpResponse object |
| // created by |CreateResponseForTestServer| and will outlive it. |
| void SendResponse( |
| base::WeakPtr<net::test_server::HttpResponseDelegate> delegate); |
| |
| // Runs |delayed_response_callback_| to send the delayed response. |
| void SendDelayedResponse(); |
| |
| private: |
| // Parses the request headers. |
| void ParseRequestHeader(); |
| |
| // Sends the response headers. |
| void SendResponseHeaders(); |
| |
| // Called to append the range headers to |response| when validator matches. |
| // Returns true if the range headers can be added, or false if the request |
| // is invalid. |
| bool HandleRangeAssumingValidatorMatch(std::string& response); |
| |
| // Adds headers that describe the entity (Content-Type, ETag, Last-Modified). |
| std::string GetCommonEntityHeaders(); |
| |
| // Gets the default response headers to send. |
| std::string GetDefaultResponseHeaders(); |
| |
| // Gets response header and body for range request starts from |
| // |first_byte_position|, and whether to delay sending the response. |
| // Returns false if no specific responses are found. |
| bool GetResponseForRangeRequest(std::string* output, bool* delay_response); |
| |
| // Gets response body chunk based on random seed in |parameters_|. |
| std::string GetResponseChunk(const net::HttpByteRange& buffer_range); |
| |
| // Pause or interrupt with injected errors. |
| bool ShouldAbortImmediately() const; |
| bool ShouldPauseImmediately() const; |
| bool HandlePause(const net::HttpByteRange& buffer_range); |
| bool HandleInjectedError(const net::HttpByteRange& buffer_range); |
| |
| // Used to pause the response sending. |
| bool ShouldPause(const net::HttpByteRange& buffer_range) const; |
| void PauseResponsesAndWaitForResumption(); |
| |
| // Send part of the response entity body in small buffers, each chunk will be |
| // send in one IOBuffer from embedded test server. |
| // Will pause or throw error based on configuration in |paramters_|. |
| void SendResponseBodyChunk(); |
| void SendBodyChunkInternal(const net::HttpByteRange& buffer_range, |
| base::OnceClosure next); |
| base::OnceClosure SendNextBodyChunkClosure(); |
| |
| // Generate CompletedRequest as result. |
| void GenerateResult(); |
| base::OnceClosure GenerateResultClosure(); |
| |
| // The parsed range of the HTTP request. The last byte position can be larger |
| // than the file size. |
| net::HttpByteRange request_range_; |
| |
| // The range of the HTTP response sent from test server, computed based on |
| // range request header and |parameters_|. The last byte position may be |
| // adjusted to the end of file size. |
| net::HttpByteRange range_; |
| |
| // The offset of response bytes sent, will send data according to |range_|. |
| int64_t response_sent_offset_; |
| |
| // Parameters associated with this response. |
| Parameters parameters_; |
| |
| // Request received from the client. |
| net::test_server::HttpRequest request_; |
| |
| // The delegate responsible for sending bytes and finishing the connection |
| base::WeakPtr<net::test_server::HttpResponseDelegate> response_delegate_ = |
| nullptr; |
| |
| // The number of bytes transferred. |
| int64_t transferred_bytes_; |
| |
| // Callback to run when the response is sent. |
| OnResponseSentCallback on_response_sent_callback_; |
| |
| // If |delay_response| is true in SetResponseForRangeRequest(), this |
| // callback will be used to send the delayed response when |
| // SendDelayedResponse() is called. |
| base::OnceClosure delayed_response_callback_; |
| |
| base::WeakPtrFactory<TestDownloadHttpResponse> weak_ptr_factory_{this}; |
| }; |
| |
| // Class for creating and monitoring the completed response from the server. |
| // Lives on UI thread. |
| // |
| // Example usage with TestDownloadHttpResponse: |
| // |
| // test_response_handler->RegisterToTestServer(embedded_test_server()); |
| // EXPECT_TRUE(embedded_test_server()->Start()); |
| // GURL url = embedded_test_server()->GetURL("/random-url"); |
| // |
| // content::TestDownloadHttpResponse::Parameters parameters; |
| // // Tweak the |parameters| here. |
| // content::TestDownloadHttpResponse::StartServing(parameters, url); |
| |
| class TestDownloadResponseHandler { |
| public: |
| std::unique_ptr<net::test_server::HttpResponse> HandleTestDownloadRequest( |
| TestDownloadHttpResponse::OnResponseSentCallback callback, |
| const net::test_server::HttpRequest& request); |
| |
| TestDownloadResponseHandler(); |
| |
| TestDownloadResponseHandler(const TestDownloadResponseHandler&) = delete; |
| TestDownloadResponseHandler& operator=(const TestDownloadResponseHandler&) = |
| delete; |
| |
| ~TestDownloadResponseHandler(); |
| |
| // Register to the embedded test |server|. |
| void RegisterToTestServer(net::test_server::EmbeddedTestServer* server); |
| |
| void OnRequestCompleted( |
| std::unique_ptr<TestDownloadHttpResponse::CompletedRequest> request); |
| |
| // Wait for a certain number of requests to complete. |
| void WaitUntilCompletion(size_t request_count); |
| |
| // Called to dispatch all delayed responses if there are any. |
| void DispatchDelayedResponses(); |
| |
| using CompletedRequests = |
| std::vector<std::unique_ptr<TestDownloadHttpResponse::CompletedRequest>>; |
| CompletedRequests const& completed_requests() { return completed_requests_; } |
| |
| private: |
| // Lives on on embedded test server's IO thread. |
| std::vector<std::unique_ptr<TestDownloadHttpResponse>> responses_; |
| |
| CompletedRequests completed_requests_; |
| size_t request_count_ = 0u; |
| std::unique_ptr<base::RunLoop> run_loop_; |
| scoped_refptr<base::SingleThreadTaskRunner> server_task_runner_; |
| SEQUENCE_CHECKER(sequence_checker_); |
| }; |
| |
| } // namespace content |
| |
| #endif // CONTENT_PUBLIC_TEST_TEST_DOWNLOAD_HTTP_RESPONSE_H_ |