1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
// Copyright 2014 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.
import "mojo/services/public/interfaces/network/network_error.mojom"
module mojo {
struct URLRequest {
// The URL to load.
string? url;
// The HTTP method if applicable.
string? method = "GET";
// Additional HTTP request headers.
array<string?>? headers;
// The payload for the request body, represented as a concatenation of data
// streams. For HTTP requests, the method must be set to "POST" or "PUT".
array<handle<data_pipe_consumer>?>? body;
// The number of bytes to be read from |body|. A Content-Length header of
// this value will be sent. Set to -1 if length is unknown, which will cause
// |body| to be uploaded using a chunked encoding.
int64 body_length = 0;
// The buffer size of the data pipe returned in URLResponse's |body| member.
// A value of 0 indicates that the default buffer size should be used. This
// value is just a suggestion. The URLLoader may choose to ignore this value.
uint32 response_body_buffer_size = 0;
// If set to true, then redirects will be automatically followed. Otherwise,
// when a redirect is encounterd, FollowRedirect must be called to proceed.
bool auto_follow_redirects = false;
// If set to true, then the HTTP request will bypass the local cache and will
// have a 'Cache-Control: nocache' header added in that causes any proxy
// servers to also not satisfy the request from their cache. This has the
// effect of forcing a full end-to-end fetch.
bool bypass_cache = false;
};
struct URLResponse {
// If the response resulted in a network level error, this field will be set.
NetworkError? error;
// The response body stream. Read from this data pipe to receive the bytes of
// response body.
handle<data_pipe_consumer>? body;
// The final URL of the response, after redirects have been followed.
string? url;
// The HTTP status code. 0 if not applicable.
uint32 status_code;
// The HTTP status line.
string? status_line;
// The HTTP response headers.
array<string?>? headers;
// The MIME type of the response body.
string? mime_type;
// The character set of the response body.
string? charset;
// These fields are set to non-NULL if this response corresponds to a
// redirect. Call the |FollowRedirect| method on the URLLoader instance to
// follow this redirect.
string? redirect_method;
string? redirect_url;
};
struct URLLoaderStatus {
// If the loader has failed due to a network level error, this field will be
// set.
NetworkError? error;
// Set to true if the URLLoader is still working. Set to false once an error
// is encountered or the response body is completely copied to the response
// body stream.
bool is_loading;
// TODO(darin): Add further details about the stages of loading (e.g.,
// "resolving host") that happen prior to receiving bytes.
};
interface URLLoader {
// Loads the given |request|, asynchronously producing |response|. Consult
// |response| to determine if the request resulted in an error, was
// redirected, or has a response body to be consumed.
Start(URLRequest? request) => (URLResponse? response);
// If the request passed to |Start| had |auto_follow_redirects| set to false,
// then upon receiving an URLResponse with a non-NULL |redirect_url| field,
// |FollowRedirect| may be called to load the URL indicated by the redirect.
FollowRedirect() => (URLResponse? response);
// Query status about the URLLoader.
QueryStatus() => (URLLoaderStatus? status);
};
}
|
