AU: Manual proxy support

http_fetcher_unittest.cc

 // 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.
 
 #include <unistd.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "base/logging.h"
-#include "base/scoped_ptr.h"
-#include "base/string_util.h"
-#include "glib.h"
-#include "gtest/gtest.h"
+#include <base/logging.h>
+#include <base/scoped_ptr.h>
+#include <base/string_util.h>
+#include <glib.h>
+#include <gtest/gtest.h>
+
 #include "update_engine/libcurl_http_fetcher.h"
 #include "update_engine/mock_http_fetcher.h"
 #include "update_engine/multi_http_fetcher.h"
+#include "update_engine/proxy_resolver.h"
 
 using std::make_pair;
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 namespace {
 // WARNING, if you update these, you must also update test_http_server.cc.
 const char* const kServerPort = "8088";
@@ skipping 20 matching lines @@
   ~NullHttpServer() {}
   bool started_;
 };
 
 
 template <>
 class HttpFetcherTest<MockHttpFetcher> : public ::testing::Test {
  public:
   HttpFetcher* NewLargeFetcher() {
     vector<char> big_data(1000000);
-    return new MockHttpFetcher(big_data.data(), big_data.size());
+    return new MockHttpFetcher(
+        big_data.data(),
+        big_data.size(),
+        reinterpret_cast<ProxyResolver*>(&proxy_resolver_));
   }
   HttpFetcher* NewSmallFetcher() {
-    return new MockHttpFetcher("x", 1);
+    return new MockHttpFetcher(
+        "x",
+        1,
+        reinterpret_cast<ProxyResolver*>(&proxy_resolver_));
   }
   string BigUrl() const {
     return "unused://unused";
   }
   string SmallUrl() const {
     return "unused://unused";
   }
   bool IsMock() const { return true; }
   bool IsMulti() const { return false; }
   typedef NullHttpServer HttpServer;
   void IgnoreServerAborting(HttpServer* server) const {}
+  
+  DirectProxyResolver proxy_resolver_;
 };
 
 class PythonHttpServer {
  public:
   PythonHttpServer() {
     char *argv[2] = {strdup("./test_http_server"), NULL};
     GError *err;
     started_ = false;
     validate_quit_ = true;
     if (!g_spawn_async(NULL,
@@ skipping 40 matching lines @@
   }
   GPid pid_;
   bool started_;
   bool validate_quit_;
 };
 
 template <>
 class HttpFetcherTest<LibcurlHttpFetcher> : public ::testing::Test {
  public:
   virtual HttpFetcher* NewLargeFetcher() {
-    LibcurlHttpFetcher *ret = new LibcurlHttpFetcher;
+    LibcurlHttpFetcher *ret = new
+        LibcurlHttpFetcher(reinterpret_cast<ProxyResolver*>(&proxy_resolver_));
     // Speed up test execution.
     ret->set_idle_seconds(1);
     ret->set_retry_seconds(1);
     ret->SetConnectionAsExpensive(false);
     ret->SetBuildType(false);
     return ret;
   }
   HttpFetcher* NewSmallFetcher() {
     return NewLargeFetcher();
   }
   string BigUrl() const {
     return LocalServerUrlForPath("/big");
   }
   string SmallUrl() const {
     return LocalServerUrlForPath("/foo");
   }
   bool IsMock() const { return false; }
   bool IsMulti() const { return false; }
   typedef PythonHttpServer HttpServer;
   void IgnoreServerAborting(HttpServer* server) const {
     PythonHttpServer *pyserver = reinterpret_cast<PythonHttpServer*>(server);
     pyserver->validate_quit_ = false;
   }
+  DirectProxyResolver proxy_resolver_;
 };
 
 template <>
 class HttpFetcherTest<MultiHttpFetcher<LibcurlHttpFetcher> >
     : public HttpFetcherTest<LibcurlHttpFetcher> {
  public:
   HttpFetcher* NewLargeFetcher() {
     MultiHttpFetcher<LibcurlHttpFetcher> *ret =
-        new MultiHttpFetcher<LibcurlHttpFetcher>;
+        new MultiHttpFetcher<LibcurlHttpFetcher>(
+            reinterpret_cast<ProxyResolver*>(&proxy_resolver_));
     MultiHttpFetcher<LibcurlHttpFetcher>::RangesVect
         ranges(1, make_pair(0, -1));
     ret->set_ranges(ranges);
     // Speed up test execution.
     ret->set_idle_seconds(1);
     ret->set_retry_seconds(1);
     ret->SetConnectionAsExpensive(false);
     ret->SetBuildType(false);
     return ret;
   }
   bool IsMulti() const { return true; }
+  DirectProxyResolver proxy_resolver_;
 };
 
 typedef ::testing::Types<LibcurlHttpFetcher,
                          MockHttpFetcher,
                          MultiHttpFetcher<LibcurlHttpFetcher> >
 HttpFetcherTestTypes;
 TYPED_TEST_CASE(HttpFetcherTest, HttpFetcherTestTypes);
 
 namespace {
 class HttpFetcherTestDelegate : public HttpFetcherDelegate {
@@ skipping 594 matching lines @@
     StartTransferArgs start_xfer_args =
         { fetcher.get(), LocalServerUrlForPath(this->SmallUrl()) };
 
     g_timeout_add(0, StartTransfer, &start_xfer_args);
     g_main_loop_run(loop);
     g_main_loop_unref(loop);
   }
 }
 
 }  // namespace chromeos_update_engine