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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
// 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.
#ifndef CHROME_BROWSER_SYNC_GLUE_HTTP_BRIDGE_H_
#define CHROME_BROWSER_SYNC_GLUE_HTTP_BRIDGE_H_
#pragma once
#include <string>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/gtest_prod_util.h"
#include "base/memory/ref_counted.h"
#include "base/synchronization/lock.h"
#include "base/synchronization/waitable_event.h"
#include "googleurl/src/gurl.h"
#include "net/url_request/url_fetcher_delegate.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_getter.h"
#include "sync/internal_api/public/http_post_provider_factory.h"
#include "sync/internal_api/public/http_post_provider_interface.h"
class MessageLoop;
class HttpBridgeTest;
namespace net {
class HttpResponseHeaders;
class URLFetcher;
}
namespace browser_sync {
// A bridge between the syncer and Chromium HTTP layers.
// Provides a way for the sync backend to use Chromium directly for HTTP
// requests rather than depending on a third party provider (e.g libcurl).
// This is a one-time use bridge. Create one for each request you want to make.
// It is RefCountedThreadSafe because it can PostTask to the io loop, and thus
// needs to stick around across context switches, etc.
class HttpBridge : public base::RefCountedThreadSafe<HttpBridge>,
public csync::HttpPostProviderInterface,
public net::URLFetcherDelegate {
public:
// A request context used for HTTP requests bridged from the sync backend.
// A bridged RequestContext has a dedicated in-memory cookie store and does
// not use a cache. Thus the same type can be used for incognito mode.
class RequestContext : public net::URLRequestContext {
public:
// |baseline_context| is used to obtain the accept-language,
// accept-charsets, and proxy service information for bridged requests.
// Typically |baseline_context| should be the net::URLRequestContext of the
// currently active profile.
explicit RequestContext(net::URLRequestContext* baseline_context);
// The destructor MUST be called on the IO thread.
virtual ~RequestContext();
// Set the user agent for requests using this context. The default is
// the browser's UA string.
void set_user_agent(const std::string& ua) { user_agent_ = ua; }
virtual const std::string& GetUserAgent(const GURL& url) const OVERRIDE {
// If the user agent is set explicitly return that, otherwise call the
// base class method to return default value.
return user_agent_.empty() ?
net::URLRequestContext::GetUserAgent(url) : user_agent_;
}
private:
std::string user_agent_;
net::URLRequestContext* baseline_context_;
DISALLOW_COPY_AND_ASSIGN(RequestContext);
};
// Lazy-getter for RequestContext objects.
class RequestContextGetter : public net::URLRequestContextGetter {
public:
explicit RequestContextGetter(
net::URLRequestContextGetter* baseline_context_getter);
void set_user_agent(const std::string& ua) { user_agent_ = ua; }
bool is_user_agent_set() const { return !user_agent_.empty(); }
// net::URLRequestContextGetter implementation.
virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE;
virtual scoped_refptr<base::SingleThreadTaskRunner>
GetNetworkTaskRunner() const OVERRIDE;
protected:
virtual ~RequestContextGetter();
private:
// User agent to apply to the net::URLRequestContext.
std::string user_agent_;
scoped_refptr<net::URLRequestContextGetter> baseline_context_getter_;
// Lazily initialized by GetURLRequestContext().
scoped_ptr<RequestContext> context_;
DISALLOW_COPY_AND_ASSIGN(RequestContextGetter);
};
explicit HttpBridge(RequestContextGetter* context);
// csync::HttpPostProvider implementation.
virtual void SetUserAgent(const char* user_agent) OVERRIDE;
virtual void SetExtraRequestHeaders(const char* headers) OVERRIDE;
virtual void SetURL(const char* url, int port) OVERRIDE;
virtual void SetPostPayload(const char* content_type, int content_length,
const char* content) OVERRIDE;
virtual bool MakeSynchronousPost(int* error_code,
int* response_code) OVERRIDE;
virtual void Abort() OVERRIDE;
// WARNING: these response content methods are used to extract plain old data
// and not null terminated strings, so you should make sure you have read
// GetResponseContentLength() characters when using GetResponseContent. e.g
// string r(b->GetResponseContent(), b->GetResponseContentLength()).
virtual int GetResponseContentLength() const OVERRIDE;
virtual const char* GetResponseContent() const OVERRIDE;
virtual const std::string GetResponseHeaderValue(
const std::string& name) const OVERRIDE;
// net::URLFetcherDelegate implementation.
virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
#if defined(UNIT_TEST)
net::URLRequestContextGetter* GetRequestContextGetter() const {
return context_getter_for_request_;
}
#endif
protected:
friend class base::RefCountedThreadSafe<HttpBridge>;
virtual ~HttpBridge();
// Protected virtual so the unit test can override to shunt network requests.
virtual void MakeAsynchronousPost();
private:
friend class ::HttpBridgeTest;
// Called on the IO loop to issue the network request. The extra level
// of indirection is so that the unit test can override this behavior but we
// still have a function to statically pass to PostTask.
void CallMakeAsynchronousPost() { MakeAsynchronousPost(); }
// Used to destroy a fetcher when the bridge is Abort()ed, to ensure that
// a reference to |this| is held while flushing any pending fetch completion
// callbacks coming from the IO thread en route to finally destroying the
// fetcher.
void DestroyURLFetcherOnIOThread(net::URLFetcher* fetcher);
// Gets a customized net::URLRequestContext for bridged requests. See
// RequestContext definition for details.
scoped_refptr<RequestContextGetter> context_getter_for_request_;
// The message loop of the thread we were created on. This is the thread that
// will block on MakeSynchronousPost while the IO thread fetches data from
// the network.
// This should be the main syncer thread (SyncerThread) which is what blocks
// on network IO through curl_easy_perform.
MessageLoop* const created_on_loop_;
// The URL to POST to.
GURL url_for_request_;
// POST payload information.
std::string content_type_;
std::string request_content_;
std::string extra_headers_;
// A waitable event we use to provide blocking semantics to
// MakeSynchronousPost. We block created_on_loop_ while the IO loop fetches
// network request.
base::WaitableEvent http_post_completed_;
struct URLFetchState {
URLFetchState();
~URLFetchState();
// Our hook into the network layer is a URLFetcher. USED ONLY ON THE IO
// LOOP, so we can block created_on_loop_ while the fetch is in progress.
// NOTE: This is not a scoped_ptr for a reason. It must be deleted on the
// same thread that created it, which isn't the same thread |this| gets
// deleted on. We must manually delete url_poster_ on the IO loop.
net::URLFetcher* url_poster;
// Used to support 'Abort' functionality.
bool aborted;
// Cached response data.
bool request_completed;
bool request_succeeded;
int http_response_code;
int error_code;
std::string response_content;
scoped_refptr<net::HttpResponseHeaders> response_headers;
};
// This lock synchronizes use of state involved in the flow to fetch a URL
// using URLFetcher. Because we can Abort() from any thread, for example,
// this flow needs to be synchronized to gracefully clean up URLFetcher and
// return appropriate values in |error_code|.
mutable base::Lock fetch_state_lock_;
URLFetchState fetch_state_;
DISALLOW_COPY_AND_ASSIGN(HttpBridge);
};
class HttpBridgeFactory : public csync::HttpPostProviderFactory {
public:
explicit HttpBridgeFactory(
net::URLRequestContextGetter* baseline_context_getter);
virtual ~HttpBridgeFactory();
// csync::HttpPostProviderFactory:
virtual csync::HttpPostProviderInterface* Create() OVERRIDE;
virtual void Destroy(csync::HttpPostProviderInterface* http) OVERRIDE;
private:
// This request context is built on top of the baseline context and shares
// common components.
HttpBridge::RequestContextGetter* GetRequestContextGetter();
scoped_refptr<HttpBridge::RequestContextGetter> request_context_getter_;
DISALLOW_COPY_AND_ASSIGN(HttpBridgeFactory);
};
} // namespace browser_sync
#endif // CHROME_BROWSER_SYNC_GLUE_HTTP_BRIDGE_H_
|