rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 1 | // Copyright (c) 2009 The Chromium OS Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 5 | #ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_LIBCURL_HTTP_FETCHER_H__ |
| 6 | #define CHROMEOS_PLATFORM_UPDATE_ENGINE_LIBCURL_HTTP_FETCHER_H__ |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 7 | |
| 8 | #include <map> |
| 9 | #include <string> |
Bruno Rocha | 7f9aea2 | 2011-09-12 14:31:24 -0700 | [diff] [blame] | 10 | |
| 11 | #include <base/basictypes.h> |
| 12 | #include <base/logging.h> |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 13 | #include <curl/curl.h> |
| 14 | #include <glib.h> |
Bruno Rocha | 7f9aea2 | 2011-09-12 14:31:24 -0700 | [diff] [blame] | 15 | |
| 16 | #include "update_engine/certificate_checker.h" |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 17 | #include "update_engine/connection_manager.h" |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 18 | #include "update_engine/http_fetcher.h" |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 19 | #include "update_engine/system_state.h" |
| 20 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 21 | |
| 22 | // This is a concrete implementation of HttpFetcher that uses libcurl to do the |
| 23 | // http work. |
| 24 | |
| 25 | namespace chromeos_update_engine { |
| 26 | |
| 27 | class LibcurlHttpFetcher : public HttpFetcher { |
| 28 | public: |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 29 | LibcurlHttpFetcher(ProxyResolver* proxy_resolver, |
Gilad Arnold | 7c04e76 | 2012-05-23 10:54:02 -0700 | [diff] [blame] | 30 | SystemState* system_state, |
| 31 | bool is_test_mode) |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 32 | : HttpFetcher(proxy_resolver, system_state), |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 33 | curl_multi_handle_(NULL), |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 34 | curl_handle_(NULL), |
Gilad Arnold | 9dd1e7c | 2012-02-16 12:13:36 -0800 | [diff] [blame] | 35 | curl_http_headers_(NULL), |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 36 | timeout_source_(NULL), |
| 37 | transfer_in_progress_(false), |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 38 | transfer_size_(0), |
| 39 | bytes_downloaded_(0), |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 40 | download_length_(0), |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 41 | resume_offset_(0), |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 42 | retry_count_(0), |
David Zeuthen | 34135a9 | 2013-08-06 11:16:16 -0700 | [diff] [blame] | 43 | max_retry_count_(kDownloadMaxRetryCount), |
Gilad Arnold | 34bf1ee | 2012-02-09 16:16:02 -0800 | [diff] [blame] | 44 | retry_seconds_(20), |
Darin Petkov | a092955 | 2010-11-29 14:19:06 -0800 | [diff] [blame] | 45 | no_network_retry_count_(0), |
| 46 | no_network_max_retries_(0), |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 47 | idle_seconds_(1), |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 48 | force_build_type_(false), |
| 49 | forced_official_build_(false), |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 50 | in_write_callback_(false), |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 51 | sent_byte_(false), |
Bruno Rocha | 7f9aea2 | 2011-09-12 14:31:24 -0700 | [diff] [blame] | 52 | terminate_requested_(false), |
Gilad Arnold | 7c04e76 | 2012-05-23 10:54:02 -0700 | [diff] [blame] | 53 | check_certificate_(CertificateChecker::kNone), |
David Zeuthen | 34135a9 | 2013-08-06 11:16:16 -0700 | [diff] [blame] | 54 | is_test_mode_(is_test_mode), |
| 55 | low_speed_limit_bps_(kDownloadLowSpeedLimitBps), |
| 56 | low_speed_time_seconds_(kDownloadLowSpeedTimeSeconds), |
| 57 | connect_timeout_seconds_(kDownloadConnectTimeoutSeconds) { |
| 58 | // Dev users want a longer timeout (180 seconds) because they may |
| 59 | // be waiting on the dev server to build an image. |
| 60 | if (!IsOfficialBuild()) |
| 61 | low_speed_time_seconds_ = kDownloadDevModeLowSpeedTimeSeconds; |
| 62 | if (!system_state_->IsOOBEComplete()) |
| 63 | max_retry_count_ = kDownloadMaxRetryCountOobeNotComplete; |
| 64 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 65 | |
| 66 | // Cleans up all internal state. Does not notify delegate |
| 67 | ~LibcurlHttpFetcher(); |
| 68 | |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 69 | virtual void SetOffset(off_t offset) { bytes_downloaded_ = offset; } |
| 70 | |
| 71 | virtual void SetLength(size_t length) { download_length_ = length; } |
| 72 | virtual void UnsetLength() { SetLength(0); } |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 73 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 74 | // Begins the transfer if it hasn't already begun. |
| 75 | virtual void BeginTransfer(const std::string& url); |
| 76 | |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 77 | // If the transfer is in progress, aborts the transfer early. The transfer |
| 78 | // cannot be resumed. |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 79 | virtual void TerminateTransfer(); |
| 80 | |
| 81 | // Suspend the transfer by calling curl_easy_pause(CURLPAUSE_ALL). |
| 82 | virtual void Pause(); |
| 83 | |
| 84 | // Resume the transfer by calling curl_easy_pause(CURLPAUSE_CONT). |
| 85 | virtual void Unpause(); |
| 86 | |
| 87 | // Libcurl sometimes asks to be called back after some time while |
| 88 | // leaving that time unspecified. In that case, we pick a reasonable |
| 89 | // default of one second, but it can be overridden here. This is |
| 90 | // primarily useful for testing. |
| 91 | // From http://curl.haxx.se/libcurl/c/curl_multi_timeout.html: |
| 92 | // if libcurl returns a -1 timeout here, it just means that libcurl |
| 93 | // currently has no stored timeout value. You must not wait too long |
| 94 | // (more than a few seconds perhaps) before you call |
| 95 | // curl_multi_perform() again. |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 96 | void set_idle_seconds(int seconds) { idle_seconds_ = seconds; } |
| 97 | |
| 98 | // Sets the retry timeout. Useful for testing. |
| 99 | void set_retry_seconds(int seconds) { retry_seconds_ = seconds; } |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 100 | |
Darin Petkov | a092955 | 2010-11-29 14:19:06 -0800 | [diff] [blame] | 101 | void set_no_network_max_retries(int retries) { |
| 102 | no_network_max_retries_ = retries; |
| 103 | } |
| 104 | |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 105 | void SetBuildType(bool is_official) { |
| 106 | force_build_type_ = true; |
| 107 | forced_official_build_ = is_official; |
| 108 | } |
| 109 | |
Bruno Rocha | 7f9aea2 | 2011-09-12 14:31:24 -0700 | [diff] [blame] | 110 | void set_check_certificate( |
| 111 | CertificateChecker::ServerToCheck check_certificate) { |
| 112 | check_certificate_ = check_certificate; |
| 113 | } |
| 114 | |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 115 | virtual size_t GetBytesDownloaded() { |
| 116 | return static_cast<size_t>(bytes_downloaded_); |
| 117 | } |
| 118 | |
David Zeuthen | 34135a9 | 2013-08-06 11:16:16 -0700 | [diff] [blame] | 119 | virtual void set_low_speed_limit(int low_speed_bps, int low_speed_sec) { |
| 120 | low_speed_limit_bps_ = low_speed_bps; |
| 121 | low_speed_time_seconds_ = low_speed_sec; |
| 122 | } |
| 123 | |
| 124 | virtual void set_connect_timeout(int connect_timeout_seconds) { |
| 125 | connect_timeout_seconds_ = connect_timeout_seconds; |
| 126 | } |
| 127 | |
| 128 | virtual void set_max_retry_count(int max_retry_count) { |
| 129 | max_retry_count_ = max_retry_count; |
| 130 | } |
| 131 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 132 | private: |
Andrew de los Reyes | f3ed8e7 | 2011-02-16 10:35:46 -0800 | [diff] [blame] | 133 | // Callback for when proxy resolution has completed. This begins the |
| 134 | // transfer. |
| 135 | void ProxiesResolved(); |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 136 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 137 | // Asks libcurl for the http response code and stores it in the object. |
| 138 | void GetHttpResponseCode(); |
| 139 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 140 | // Checks whether stored HTTP response is within the success range. |
Gilad Arnold | 48085ba | 2011-11-16 09:36:08 -0800 | [diff] [blame] | 141 | inline bool IsHttpResponseSuccess() { |
| 142 | return (http_response_code_ >= 200 && http_response_code_ < 300); |
| 143 | } |
| 144 | |
Gilad Arnold | 9bedeb5 | 2011-11-17 16:19:57 -0800 | [diff] [blame] | 145 | // Checks whether stored HTTP response is within the error range. This |
| 146 | // includes both errors with the request (4xx) and server errors (5xx). |
| 147 | inline bool IsHttpResponseError() { |
| 148 | return (http_response_code_ >= 400 && http_response_code_ < 600); |
| 149 | } |
| 150 | |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 151 | // Resumes a transfer where it left off. This will use the |
| 152 | // HTTP Range: header to make a new connection from where the last |
| 153 | // left off. |
| 154 | virtual void ResumeTransfer(const std::string& url); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 155 | |
| 156 | // These two methods are for glib main loop callbacks. They are called |
| 157 | // when either a file descriptor is ready for work or when a timer |
| 158 | // has fired. The static versions are shims for libcurl which has a C API. |
| 159 | bool FDCallback(GIOChannel *source, GIOCondition condition); |
| 160 | static gboolean StaticFDCallback(GIOChannel *source, |
| 161 | GIOCondition condition, |
| 162 | gpointer data) { |
| 163 | return reinterpret_cast<LibcurlHttpFetcher*>(data)->FDCallback(source, |
| 164 | condition); |
| 165 | } |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 166 | gboolean TimeoutCallback(); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 167 | static gboolean StaticTimeoutCallback(gpointer data) { |
| 168 | return reinterpret_cast<LibcurlHttpFetcher*>(data)->TimeoutCallback(); |
| 169 | } |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 170 | |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 171 | gboolean RetryTimeoutCallback(); |
| 172 | static gboolean StaticRetryTimeoutCallback(void* arg) { |
| 173 | return static_cast<LibcurlHttpFetcher*>(arg)->RetryTimeoutCallback(); |
| 174 | } |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 175 | |
| 176 | // Calls into curl_multi_perform to let libcurl do its work. Returns after |
| 177 | // curl_multi_perform is finished, which may actually be after more than |
| 178 | // one call to curl_multi_perform. This method will set up the glib run |
| 179 | // loop with sources for future work that libcurl will do. |
| 180 | // This method will not block. |
Andrew de los Reyes | 3270f74 | 2010-07-15 22:28:14 -0700 | [diff] [blame] | 181 | // Returns true if we should resume immediately after this call. |
Andrew de los Reyes | cb31933 | 2010-07-19 10:55:01 -0700 | [diff] [blame] | 182 | void CurlPerformOnce(); |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 183 | |
| 184 | // Sets up glib main loop sources as needed by libcurl. This is generally |
| 185 | // the file descriptor of the socket and a timer in case nothing happens |
| 186 | // on the fds. |
| 187 | void SetupMainloopSources(); |
| 188 | |
| 189 | // Callback called by libcurl when new data has arrived on the transfer |
| 190 | size_t LibcurlWrite(void *ptr, size_t size, size_t nmemb); |
| 191 | static size_t StaticLibcurlWrite(void *ptr, size_t size, |
| 192 | size_t nmemb, void *stream) { |
| 193 | return reinterpret_cast<LibcurlHttpFetcher*>(stream)-> |
| 194 | LibcurlWrite(ptr, size, nmemb); |
| 195 | } |
| 196 | |
| 197 | // Cleans up the following if they are non-null: |
| 198 | // curl(m) handles, io_channels_, timeout_source_. |
| 199 | void CleanUp(); |
| 200 | |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 201 | // Force terminate the transfer. This will invoke the delegate's (if any) |
| 202 | // TransferTerminated callback so, after returning, this fetcher instance may |
| 203 | // be destroyed. |
| 204 | void ForceTransferTermination(); |
| 205 | |
Jay Srinivasan | 4348879 | 2012-06-19 00:25:31 -0700 | [diff] [blame] | 206 | // Returns true if updates are allowed over the current type of connection. |
| 207 | // False otherwise. |
| 208 | bool IsUpdateAllowedOverCurrentConnection() const; |
Andrew de los Reyes | d57d147 | 2010-10-21 13:34:08 -0700 | [diff] [blame] | 209 | |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 210 | // Returns whether or not the current build is official. |
| 211 | bool IsOfficialBuild() const; |
| 212 | |
Jay Srinivasan | b3f5540 | 2012-12-03 18:12:04 -0800 | [diff] [blame] | 213 | // Sets the curl options for HTTP URL. |
| 214 | void SetCurlOptionsForHttp(); |
| 215 | |
| 216 | // Sets the curl options for HTTPS URL. |
| 217 | void SetCurlOptionsForHttps(); |
| 218 | |
Gilad Arnold | 59d9e01 | 2013-07-23 16:41:43 -0700 | [diff] [blame] | 219 | // Convert a proxy URL into a curl proxy type, if applicable. Returns true iff |
| 220 | // conversion was successful, false otherwise (in which case nothing is |
| 221 | // written to |out_type|). |
| 222 | bool GetProxyType(const std::string& proxy, curl_proxytype* out_type); |
| 223 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 224 | // Handles for the libcurl library |
| 225 | CURLM *curl_multi_handle_; |
| 226 | CURL *curl_handle_; |
Gilad Arnold | 9dd1e7c | 2012-02-16 12:13:36 -0800 | [diff] [blame] | 227 | struct curl_slist *curl_http_headers_; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 228 | |
Darin Petkov | 60e1415 | 2010-10-27 16:57:04 -0700 | [diff] [blame] | 229 | // Lists of all read(0)/write(1) file descriptors that we're waiting on from |
| 230 | // the glib main loop. libcurl may open/close descriptors and switch their |
| 231 | // directions so maintain two separate lists so that watch conditions can be |
| 232 | // set appropriately. |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 233 | typedef std::map<int, std::pair<GIOChannel*, guint> > IOChannels; |
Darin Petkov | 60e1415 | 2010-10-27 16:57:04 -0700 | [diff] [blame] | 234 | IOChannels io_channels_[2]; |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 235 | |
| 236 | // if non-NULL, a timer we're waiting on. glib main loop will call us back |
| 237 | // when it fires. |
| 238 | GSource* timeout_source_; |
| 239 | |
| 240 | bool transfer_in_progress_; |
| 241 | |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 242 | // The transfer size. -1 if not known. |
| 243 | off_t transfer_size_; |
| 244 | |
| 245 | // How many bytes have been downloaded and sent to the delegate. |
| 246 | off_t bytes_downloaded_; |
| 247 | |
Gilad Arnold | e4ad250 | 2011-12-29 17:08:54 -0800 | [diff] [blame] | 248 | // The remaining maximum number of bytes to download. Zero represents an |
| 249 | // unspecified length. |
| 250 | size_t download_length_; |
| 251 | |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 252 | // If we resumed an earlier transfer, data offset that we used for the |
| 253 | // new connection. 0 otherwise. |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 254 | // In this class, resume refers to resuming a dropped HTTP connection, |
| 255 | // not to resuming an interrupted download. |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 256 | off_t resume_offset_; |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 257 | |
Jay Srinivasan | 32f2357 | 2012-06-05 13:45:07 -0700 | [diff] [blame] | 258 | // Number of resumes performed so far and the max allowed. |
Andrew de los Reyes | 9bbd187 | 2010-07-16 14:52:29 -0700 | [diff] [blame] | 259 | int retry_count_; |
Jay Srinivasan | 32f2357 | 2012-06-05 13:45:07 -0700 | [diff] [blame] | 260 | int max_retry_count_; |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 261 | |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 262 | // Seconds to wait before retrying a resume. |
| 263 | int retry_seconds_; |
| 264 | |
Darin Petkov | a092955 | 2010-11-29 14:19:06 -0800 | [diff] [blame] | 265 | // Number of resumes due to no network (e.g., HTTP response code 0). |
| 266 | int no_network_retry_count_; |
| 267 | int no_network_max_retries_; |
| 268 | |
Darin Petkov | b83371f | 2010-08-17 09:34:49 -0700 | [diff] [blame] | 269 | // Seconds to wait before asking libcurl to "perform". |
| 270 | int idle_seconds_; |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 271 | |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 272 | // If true, assume the build is official or not, according to |
| 273 | // forced_official_build_. Useful for testing. |
| 274 | bool force_build_type_; |
| 275 | bool forced_official_build_; |
| 276 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 277 | // If true, we are currently performing a write callback on the delegate. |
| 278 | bool in_write_callback_; |
Darin Petkov | a092955 | 2010-11-29 14:19:06 -0800 | [diff] [blame] | 279 | |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 280 | // If true, we have returned at least one byte in the write callback |
| 281 | // to the delegate. |
| 282 | bool sent_byte_; |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 283 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 284 | // We can't clean everything up while we're in a write callback, so |
| 285 | // if we get a terminate request, queue it until we can handle it. |
| 286 | bool terminate_requested_; |
| 287 | |
Bruno Rocha | 7f9aea2 | 2011-09-12 14:31:24 -0700 | [diff] [blame] | 288 | // Represents which server certificate to be checked against this |
| 289 | // connection's certificate. If no certificate check needs to be performed, |
| 290 | // this should be kNone. |
| 291 | CertificateChecker::ServerToCheck check_certificate_; |
| 292 | |
Gilad Arnold | 7c04e76 | 2012-05-23 10:54:02 -0700 | [diff] [blame] | 293 | // If true, utilizes a relaxed test mode fetch logic. False by default. |
| 294 | bool is_test_mode_; |
| 295 | |
David Zeuthen | 34135a9 | 2013-08-06 11:16:16 -0700 | [diff] [blame] | 296 | int low_speed_limit_bps_; |
| 297 | int low_speed_time_seconds_; |
| 298 | int connect_timeout_seconds_; |
| 299 | int num_max_retries_; |
| 300 | |
rspangler@google.com | 49fdf18 | 2009-10-10 00:57:34 +0000 | [diff] [blame] | 301 | DISALLOW_COPY_AND_ASSIGN(LibcurlHttpFetcher); |
| 302 | }; |
| 303 | |
| 304 | } // namespace chromeos_update_engine |
| 305 | |
adlr@google.com | c98a7ed | 2009-12-04 18:54:03 +0000 | [diff] [blame] | 306 | #endif // CHROMEOS_PLATFORM_UPDATE_ENGINE_LIBCURL_HTTP_FETCHER_H__ |