AU: MultiHttpFetcher cleanup/rewrite

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 "update_engine/libcurl_http_fetcher.h"
 #include "update_engine/mock_http_fetcher.h"
-#include "update_engine/multi_http_fetcher.h"
+#include "update_engine/multi_range_http_fetcher.h"
 #include "update_engine/proxy_resolver.h"
 
 using std::make_pair;
+using std::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";
 const int kBigSize = 100000;
 string LocalServerUrlForPath(const string& path) {
@@ skipping 130 matching lines @@
   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> >
+class HttpFetcherTest<MultiRangeHTTPFetcher>
     : public HttpFetcherTest<LibcurlHttpFetcher> {
  public:
   HttpFetcher* NewLargeFetcher() {
-    MultiHttpFetcher<LibcurlHttpFetcher> *ret =
-        new MultiHttpFetcher<LibcurlHttpFetcher>(
-            reinterpret_cast<ProxyResolver*>(&proxy_resolver_));
-    MultiHttpFetcher<LibcurlHttpFetcher>::RangesVect
-        ranges(1, make_pair(0, -1));
-    ret->set_ranges(ranges);
+    ProxyResolver* resolver =
+        reinterpret_cast<ProxyResolver*>(&proxy_resolver_);
+    MultiRangeHTTPFetcher *ret =
+        new MultiRangeHTTPFetcher(new LibcurlHttpFetcher(resolver));
+    ret->ClearRanges();
+    ret->AddRange(0, -1);
     // 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> >
+                         MultiRangeHTTPFetcher>
 HttpFetcherTestTypes;
 TYPED_TEST_CASE(HttpFetcherTest, HttpFetcherTestTypes);
 
 namespace {
 class HttpFetcherTestDelegate : public HttpFetcherDelegate {
  public:
   virtual void ReceivedBytes(HttpFetcher* fetcher,
                              const char* bytes, int length) {
     char str[length + 1];
     memset(str, 0, length + 1);
@@ skipping 130 matching lines @@
     ADD_FAILURE();  // We should never get here
     g_main_loop_quit(loop_);
   }
   virtual void TransferTerminated(HttpFetcher* fetcher) {
     EXPECT_EQ(fetcher, fetcher_.get());
     EXPECT_FALSE(once_);
     EXPECT_TRUE(callback_once_);
     callback_once_ = false;
     // |fetcher| can be destroyed during this callback.
     fetcher_.reset(NULL);
- }
+  }
   void TerminateTransfer() {
     CHECK(once_);
     once_ = false;
     fetcher_->TerminateTransfer();
   }
   void EndLoop() {
     g_main_loop_quit(loop_);
   }
   bool once_;
   bool callback_once_;
@@ skipping 286 matching lines @@
     ADD_FAILURE();
   }
   scoped_ptr<HttpFetcher> fetcher_;
   int expected_response_code_;
   string data;
   GMainLoop* loop_;
 };
 
 void MultiTest(HttpFetcher* fetcher_in,
                const string& url,
-               const MultiHttpFetcher<LibcurlHttpFetcher>::RangesVect& ranges,
+               const vector<pair<off_t, off_t> >& ranges,
                const string& expected_prefix,
                off_t expected_size,
                int expected_response_code) {
   GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   {
     MultiHttpFetcherTestDelegate delegate(expected_response_code);
     delegate.loop_ = loop;
     delegate.fetcher_.reset(fetcher_in);
-    MultiHttpFetcher<LibcurlHttpFetcher>* multi_fetcher =
-        dynamic_cast<MultiHttpFetcher<LibcurlHttpFetcher>*>(fetcher_in);
+    MultiRangeHTTPFetcher* multi_fetcher =
+        dynamic_cast<MultiRangeHTTPFetcher*>(fetcher_in);
     ASSERT_TRUE(multi_fetcher);
-    multi_fetcher->set_ranges(ranges);
+    multi_fetcher->ClearRanges();
+    for (vector<pair<off_t, off_t> >::const_iterator it = ranges.begin(),
+             e = ranges.end(); it != e; ++it) {
+               LOG(INFO) << "Adding range";
+      multi_fetcher->AddRange(it->first, it->second);
+    }
     multi_fetcher->SetConnectionAsExpensive(false);
     multi_fetcher->SetBuildType(false);
     multi_fetcher->set_delegate(&delegate);
 
     StartTransferArgs start_xfer_args = {multi_fetcher, url};
 
     g_timeout_add(0, StartTransfer, &start_xfer_args);
     g_main_loop_run(loop);
 
     EXPECT_EQ(expected_size, delegate.data.size());
     EXPECT_EQ(expected_prefix,
               string(delegate.data.data(), expected_prefix.size()));
   }
   g_main_loop_unref(loop);
 }
 }  // namespace {}
 
 TYPED_TEST(HttpFetcherTest, MultiHttpFetcherSimpleTest) {
   if (!this->IsMulti())
     return;
   typename TestFixture::HttpServer server;
   ASSERT_TRUE(server.started_);
 
-  MultiHttpFetcher<LibcurlHttpFetcher>::RangesVect ranges;
+  vector<pair<off_t, off_t> > ranges;
   ranges.push_back(make_pair(0, 25));
   ranges.push_back(make_pair(99, -1));
   MultiTest(this->NewLargeFetcher(),
             this->BigUrl(),
             ranges,
             "abcdefghijabcdefghijabcdejabcdefghijabcdef",
             kBigSize - (99 - 25),
             206);
 }
 
 TYPED_TEST(HttpFetcherTest, MultiHttpFetcherLengthLimitTest) {
   if (!this->IsMulti())
     return;
   typename TestFixture::HttpServer server;
   ASSERT_TRUE(server.started_);
 
-  MultiHttpFetcher<LibcurlHttpFetcher>::RangesVect ranges;
+  vector<pair<off_t, off_t> > ranges;
   ranges.push_back(make_pair(0, 24));
   MultiTest(this->NewLargeFetcher(),
             this->BigUrl(),
             ranges,
             "abcdefghijabcdefghijabcd",
             24,
             200);
 }
 
 TYPED_TEST(HttpFetcherTest, MultiHttpFetcherMultiEndTest) {
   if (!this->IsMulti())
     return;
   typename TestFixture::HttpServer server;
   ASSERT_TRUE(server.started_);
 
-  MultiHttpFetcher<LibcurlHttpFetcher>::RangesVect ranges;
+  vector<pair<off_t, off_t> > ranges;
   ranges.push_back(make_pair(kBigSize - 2, -1));
   ranges.push_back(make_pair(kBigSize - 3, -1));
   MultiTest(this->NewLargeFetcher(),
             this->BigUrl(),
             ranges,
             "ijhij",
             5,
             206);
 }
 
 TYPED_TEST(HttpFetcherTest, MultiHttpFetcherInsufficientTest) {
   if (!this->IsMulti())
     return;
   typename TestFixture::HttpServer server;
   ASSERT_TRUE(server.started_);
 
-  MultiHttpFetcher<LibcurlHttpFetcher>::RangesVect ranges;
+  vector<pair<off_t, off_t> > ranges;
   ranges.push_back(make_pair(kBigSize - 2, 4));
   for (int i = 0; i < 2; ++i) {
+    LOG(INFO) << "i = " << i;
     MultiTest(this->NewLargeFetcher(),
               this->BigUrl(),
               ranges,
               "ij",
               2,
               0);
     ranges.push_back(make_pair(0, 5));
   }
 }
 
@@ skipping 43 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