AU: Manual proxy support

http_fetcher.h

 // Copyright (c) 2009 The Chromium OS 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 CHROMEOS_PLATFORM_UPDATE_ENGINE_HTTP_FETCHER_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_HTTP_FETCHER_H__
 
+#include <deque>
 #include <string>
 #include <vector>
+
 #include <glib.h>
-#include "base/basictypes.h"
+#include <base/basictypes.h>

[petkov, 2010/11/19 05:37:15]

sort

[adlr, 2010/11/20 02:52:29]

Done.

+#include <base/logging.h>
+
+#include "update_engine/proxy_resolver.h"
 
 // This class is a simple wrapper around an HTTP library (libcurl). We can
 // easily mock out this interface for testing.
 
 // Implementations of this class should use asynchronous i/o. They can access
 // the glib main loop to request callbacks when timers or file descriptors
 // change.
 
 namespace chromeos_update_engine {
 
 class HttpFetcherDelegate;
 
 class HttpFetcher {
  public:
-  HttpFetcher()
+  explicit HttpFetcher(ProxyResolver* proxy_resolver)

[petkov, 2010/11/19 05:37:15]

a brief docstring might be useful -- can proxy_resolver be NULL?

[adlr, 2010/11/20 02:52:29]

decided to allow NULL and documented it as such.

       : post_data_set_(false),
         http_response_code_(0),
-        delegate_(NULL) {}
+        delegate_(NULL),
+        proxies_(1, kNoProxy),
+        proxy_resolver_(proxy_resolver) {}
   virtual ~HttpFetcher() {}
 
   void set_delegate(HttpFetcherDelegate* delegate) { delegate_ = delegate; }
   HttpFetcherDelegate* delegate() const { return delegate_; }
   int http_response_code() const { return http_response_code_; }
 
   // Optional: Post data to the server. The HttpFetcher should make a copy
   // of this data and upload it via HTTP POST during the transfer.
   void SetPostData(const void* data, size_t size) {
     post_data_set_ = true;
     post_data_.clear();
     const char *char_data = reinterpret_cast<const char*>(data);
     post_data_.insert(post_data_.end(), char_data, char_data + size);
   }
 
+  // Proxy methods to set the proxies, then to pop them off.
+  void ResolveProxiesForUrl(const std::string& url) {
+    if (!proxy_resolver_) {

[petkov, 2010/11/19 05:37:15]

Lots of code for a header file. I'd suggest move all the implementation into a
http_fetcher.cc.

[adlr, 2010/11/20 02:52:29]

Done.

+      LOG(ERROR) << "Missing proxy resolver!";

[petkov, 2010/11/19 05:37:15]

Why an ERROR? Maybe just default to kNoProxy. If not, did you mean to return?
Currently, you'll print an ERROR and then crash below due to NULL pointer
dereference.

[adlr, 2010/11/20 02:52:29]

fixed. NULL now legal

+    }
+    std::vector<std::string> proxies;
+    if (!proxy_resolver_->GetProxiesForUrl(url, &proxies)) {
+      // just do direct
+      proxies.push_back(kNoProxy);
+    }
+    SetProxies(proxies);
+  }
+  void SetProxies(const std::vector<std::string>& proxies) {
+    proxies_.clear();
+    proxies_.insert(proxies_.begin(), proxies.begin(), proxies.end());

[petkov, 2010/11/19 05:37:15]

you could probably just proxies_.assign(begin, end). and no need to clear.

[adlr, 2010/11/20 02:52:29]

Done.

+  }
+  const std::string& CurrentProxy() const {
+    return proxies_.front();
+  }
+  bool HasProxy() const { return !proxies_.empty(); }
+  void PopProxy() { proxies_.pop_front(); }
+
   // Downloading should resume from this offset
   virtual void SetOffset(off_t offset) = 0;
 
   // Begins the transfer to the specified URL. This fetcher instance should not
   // be destroyed until either TransferComplete, or TransferTerminated is
   // called.
   virtual void BeginTransfer(const std::string& url) = 0;
 
   // Aborts the transfer. The transfer may not abort right away -- delegate's
   // TransferTerminated() will be called when the transfer is actually done.
@@ skipping 22 matching lines @@
   bool post_data_set_;
   std::vector<char> post_data_;
 
   // The server's HTTP response code from the last transfer. This
   // field should be set to 0 when a new transfer is initiated, and
   // set to the response code when the transfer is complete.
   int http_response_code_;
 
   // The delegate; may be NULL.
   HttpFetcherDelegate* delegate_;
+
+  // Proxy servers
+  std::deque<std::string> proxies_;
+  
+  ProxyResolver* const proxy_resolver_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(HttpFetcher);
 };
 
 // Interface for delegates
 class HttpFetcherDelegate {
  public:
   // Called every time bytes are received.
   virtual void ReceivedBytes(HttpFetcher* fetcher,
                              const char* bytes,
                              int length) = 0;
 
   // Called if the fetcher seeks to a particular offset.
   virtual void SeekToOffset(off_t offset) {}
 
   // Called when the transfer has completed successfully or been aborted through
   // means other than TerminateTransfer. It's OK to destroy the |fetcher| object
   // in this callback.
   virtual void TransferComplete(HttpFetcher* fetcher, bool successful) = 0;
 
   // Called when the transfer has been aborted through TerminateTransfer. It's
   // OK to destroy the |fetcher| object in this callback.
   virtual void TransferTerminated(HttpFetcher* fetcher) {}
 };
 
 }  // namespace chromeos_update_engine
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_HTTP_FETCHER_H__