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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// Copyright (c) 2012 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.
// This file contains URLFetcher, a wrapper around URLRequest that handles
// low-level details like thread safety, ref counting, and incremental buffer
// reading. This is useful for callers who simply want to get the data from a
// URL and don't care about all the nitty-gritty details.
//
// NOTE(willchan): Only one "IO" thread is supported for URLFetcher. This is a
// temporary situation. We will work on allowing support for multiple "io"
// threads per process.
#ifndef NET_URL_REQUEST_URL_FETCHER_IMPL_H_
#define NET_URL_REQUEST_URL_FETCHER_IMPL_H_
#include <stdint.h>
#include <string>
#include "base/task/sequenced_task_runner.h"
#include "net/base/ip_endpoint.h"
#include "net/base/net_export.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "net/url_request/referrer_policy.h"
#include "net/url_request/url_fetcher.h"
namespace net {
class URLFetcherCore;
class URLFetcherDelegate;
class URLFetcherFactory;
class NET_EXPORT_PRIVATE URLFetcherImpl : public URLFetcher {
public:
URLFetcherImpl(const URLFetcherImpl&) = delete;
URLFetcherImpl& operator=(const URLFetcherImpl&) = delete;
~URLFetcherImpl() override;
// URLFetcher implementation:
void SetUploadData(const std::string& upload_content_type,
const std::string& upload_content) override;
void SetUploadFilePath(
const std::string& upload_content_type,
const base::FilePath& file_path,
uint64_t range_offset,
uint64_t range_length,
scoped_refptr<base::TaskRunner> file_task_runner) override;
void SetUploadStreamFactory(
const std::string& upload_content_type,
const CreateUploadStreamCallback& callback) override;
void SetChunkedUpload(const std::string& upload_content_type) override;
void AppendChunkToUpload(const std::string& data,
bool is_last_chunk) override;
void SetLoadFlags(int load_flags) override;
void SetAllowCredentials(bool allow_credentials) override;
int GetLoadFlags() const override;
void SetReferrer(const std::string& referrer) override;
void SetReferrerPolicy(ReferrerPolicy referrer_policy) override;
void ClearExtraRequestHeaders() override;
void AddExtraRequestHeader(const std::string& name,
const std::string& value) override;
void SetRequestContext(
URLRequestContextGetter* request_context_getter) override;
void SetInitiator(const absl::optional<url::Origin>& initiator) override;
void SetURLRequestUserData(
const void* key,
const CreateDataCallback& create_data_callback) override;
void SetStopOnRedirect(bool stop_on_redirect) override;
void SetAutomaticallyRetryOn5xx(bool retry) override;
void SetMaxRetriesOn5xx(int max_retries) override;
int GetMaxRetriesOn5xx() const override;
base::TimeDelta GetBackoffDelay() const override;
void SetAutomaticallyRetryOnNetworkChanges(int max_retries) override;
void SaveResponseToFileAtPath(
const base::FilePath& file_path,
scoped_refptr<base::SequencedTaskRunner> file_task_runner) override;
void SaveResponseToTemporaryFile(
scoped_refptr<base::SequencedTaskRunner> file_task_runner) override;
void SaveResponseWithWriter(
std::unique_ptr<URLFetcherResponseWriter> response_writer) override;
HttpResponseHeaders* GetResponseHeaders() const override;
IPEndPoint GetSocketAddress() const override;
const ProxyServer& ProxyServerUsed() const override;
bool WasCached() const override;
int64_t GetReceivedResponseContentLength() const override;
int64_t GetTotalReceivedBytes() const override;
void Start() override;
const GURL& GetOriginalURL() const override;
const GURL& GetURL() const override;
Error GetError() const override;
int GetResponseCode() const override;
void ReceivedContentWasMalformed() override;
bool GetResponseAsString(std::string* out_response_string) const override;
bool GetResponseAsFilePath(bool take_ownership,
base::FilePath* out_response_path) const override;
static void CancelAll();
static void SetIgnoreCertificateRequests(bool ignored);
// TODO(akalin): Make these private again once URLFetcher::Create()
// is in net/.
static URLFetcherFactory* factory();
// Sets the factory used by the static method Create to create a URLFetcher.
// URLFetcher does not take ownership of |factory|. A value of NULL results
// in a URLFetcher being created directly.
//
// NOTE: for safety, this should only be used through ScopedURLFetcherFactory!
static void set_factory(URLFetcherFactory* factory);
protected:
// Returns the delegate.
URLFetcherDelegate* delegate() const;
private:
friend class URLFetcherTest;
friend class URLFetcher;
friend class WaitingURLFetcherDelegate;
// |url| is the URL to send the request to.
// |request_type| is the type of request to make.
// |d| the object that will receive the callback on fetch completion.
URLFetcherImpl(const GURL& url,
RequestType request_type,
URLFetcherDelegate* d,
net::NetworkTrafficAnnotationTag traffic_annotation);
// Only used by URLFetcherTest, returns the number of URLFetcher::Core objects
// actively running.
static int GetNumFetcherCores();
const scoped_refptr<URLFetcherCore> core_;
};
} // namespace net
#endif // NET_URL_REQUEST_URL_FETCHER_IMPL_H_
|
