AU: Manual proxy support

multi_http_fetcher.h

 // Copyright (c) 2010 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_MULTI_HTTP_FETCHER_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_MULTI_HTTP_FETCHER_H__
 
+#include <deque>
 #include <tr1/memory>
 #include <utility>
 #include <vector>
 
 #include "update_engine/http_fetcher.h"
 #include "update_engine/utils.h"
 
 // This class is a simple wrapper around an HttpFetcher. The client
 // specifies a vector of byte ranges. MultiHttpFetcher will fetch bytes
 // from those offsets. Pass -1 as a length to specify unlimited length.
 // It really only would make sense for the last range specified to have
 // unlimited length.
 
 namespace chromeos_update_engine {
 
 template<typename BaseHttpFetcher>
 class MultiHttpFetcher : public HttpFetcher, public HttpFetcherDelegate {
  public:
   typedef std::vector<std::pair<off_t, off_t> > RangesVect;
+  typedef std::vector<std::tr1::shared_ptr<BaseHttpFetcher> > FetchersVect;
 
-  MultiHttpFetcher()
-      : sent_transfer_complete_(false),
+  MultiHttpFetcher(ProxyResolver* proxy_resolver)
+      : HttpFetcher(proxy_resolver),
+        sent_transfer_complete_(false),
         pending_next_fetcher_(false),
         current_index_(0),
         bytes_received_this_fetcher_(0) {}
   ~MultiHttpFetcher() {}
 
   void set_ranges(const RangesVect& ranges) {
     ranges_ = ranges;
     fetchers_.resize(ranges_.size());  // Allocate the fetchers
     for (typename std::vector<std::tr1::shared_ptr<BaseHttpFetcher>
              >::iterator it = fetchers_.begin(), e = fetchers_.end();
          it != e; ++it) {
-      (*it) = std::tr1::shared_ptr<BaseHttpFetcher>(new BaseHttpFetcher);
+      (*it) = std::tr1::shared_ptr<BaseHttpFetcher>(
+          new BaseHttpFetcher(proxy_resolver_));
       (*it)->set_delegate(this);
     }
+    LOG(INFO) << "done w/ list";
   }
 
   void SetOffset(off_t offset) {}  // for now, doesn't support this
 
   // Begins the transfer to the specified URL.
   void BeginTransfer(const std::string& url) {
     url_ = url;
     if (ranges_.empty()) {
       if (delegate_)
         delegate_->TransferComplete(this, true);
@@ skipping 73 matching lines @@
       (*it)->SetConnectionAsExpensive(is_expensive);
     }
   }
   void SetBuildType(bool is_official) {
     for (typename std::vector<std::tr1::shared_ptr<BaseHttpFetcher> >::iterator
              it = fetchers_.begin(),
              e = fetchers_.end(); it != e; ++it) {
       (*it)->SetBuildType(is_official);
     }
   }
+  
+  virtual void SetProxies(const std::deque<std::string>& proxies) {
+    for (typename FetchersVect::iterator it = fetchers_.begin(),
+             e = fetchers_.end(); it != e; ++it) {
+      (*it)->SetProxies(proxies);
+    }
+  }
 
  private:
   void SendTransferComplete(HttpFetcher* fetcher, bool successful) {
     if (sent_transfer_complete_)
       return;
     LOG(INFO) << "Sending transfer complete";
     sent_transfer_complete_ = true;
     http_response_code_ = fetcher->http_response_code();
     if (delegate_)
       delegate_->TransferComplete(this, successful);
@@ skipping 66 matching lines @@
   }
 
   // If true, do not send any more data or TransferComplete to the delegate.
   bool sent_transfer_complete_;
 
   // If true, the next fetcher needs to be started when TransferTerminated is
   // received from the current fetcher.
   bool pending_next_fetcher_;
 
   RangesVect ranges_;
-  std::vector<std::tr1::shared_ptr<BaseHttpFetcher> > fetchers_;
+  FetchersVect fetchers_;
 
   RangesVect::size_type current_index_;  // index into ranges_, fetchers_
   off_t bytes_received_this_fetcher_;
 
   DISALLOW_COPY_AND_ASSIGN(MultiHttpFetcher);
 };
 
 }  // namespace chromeos_update_engine
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_MULTI_HTTP_FETCHER_H__