AU: Push seeks in http fetching to the progress percentage.

download_action_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 <string>
 #include <vector>
 
 #include <glib.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ skipping 62 matching lines @@
   bool processing_done_called_;
   ActionExitCode expected_code_;
 };
 
 struct EntryPointArgs {
   const vector<char> *data;
   GMainLoop *loop;
   ActionProcessor *processor;
 };
 
+struct StartProcessorInRunLoopArgs {
+  ActionProcessor* processor;
+  MockHttpFetcher* http_fetcher;
+};
+
 gboolean StartProcessorInRunLoop(gpointer data) {
-  ActionProcessor *processor = reinterpret_cast<ActionProcessor*>(data);
+  ActionProcessor* processor =
+      reinterpret_cast<StartProcessorInRunLoopArgs*>(data)->processor;
   processor->StartProcessing();
+  MockHttpFetcher* http_fetcher =
+      reinterpret_cast<StartProcessorInRunLoopArgs*>(data)->http_fetcher;
+  http_fetcher->SetOffset(1);
   return FALSE;
 }
 
 void TestWithData(const vector<char>& data,
                   bool hash_test,
                   bool size_test,
                   bool use_download_delegate) {
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   // TODO(adlr): see if we need a different file for build bots
   ScopedTempFile output_temp_file;
   DirectFileWriter writer;
 
-  // takes ownership of passed in HttpFetcher
+  // We pull off the first byte from data and seek past it.
+
   string hash = hash_test ?
       OmahaHashCalculator::OmahaHashOfString("random string") :
-      OmahaHashCalculator::OmahaHashOfData(data);
+      OmahaHashCalculator::OmahaHashOfBytes(&data[1], data.size() - 1);
   uint64_t size = data.size() + (size_test ? 1 : 0);
   InstallPlan install_plan(true,
                            false,
                            "",
                            size,
                            hash,
                            output_temp_file.GetPath(),
                            "");
   ObjectFeederAction<InstallPlan> feeder_action;
   feeder_action.set_obj(install_plan);
   PrefsMock prefs;
-  DownloadAction download_action(&prefs, new MockHttpFetcher(&data[0],
-                                                             data.size()));
+  MockHttpFetcher* http_fetcher = new MockHttpFetcher(&data[0], data.size());
+  // takes ownership of passed in HttpFetcher
+  DownloadAction download_action(&prefs, http_fetcher);
   download_action.SetTestFileWriter(&writer);
   BondActions(&feeder_action, &download_action);
   DownloadActionDelegateMock download_delegate;
   if (use_download_delegate) {
     InSequence s;
     download_action.set_delegate(&download_delegate);
     EXPECT_CALL(download_delegate, SetDownloadStatus(true)).Times(1);
-    EXPECT_CALL(download_delegate, BytesReceived(_, _)).Times(AtLeast(1));
+    if (data.size() > kMockHttpFetcherChunkSize)
+      EXPECT_CALL(download_delegate,
+                  BytesReceived(1 + kMockHttpFetcherChunkSize, _));
+
+      EXPECT_CALL(download_delegate, BytesReceived(_, _)).Times(AtLeast(1));
     EXPECT_CALL(download_delegate, SetDownloadStatus(false)).Times(1);
   }
   ActionExitCode expected_code = kActionCodeSuccess;
   if (hash_test)
     expected_code = kActionCodeDownloadHashMismatchError;
   else if (size_test)
     expected_code = kActionCodeDownloadSizeMismatchError;
   DownloadActionTestProcessorDelegate delegate(expected_code);
   delegate.loop_ = loop;
-  delegate.expected_data_ = data;
+  delegate.expected_data_ = vector<char>(data.begin() + 1, data.end());
   delegate.path_ = output_temp_file.GetPath();
   ActionProcessor processor;
   processor.set_delegate(&delegate);
   processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&download_action);
 
-  g_timeout_add(0, &StartProcessorInRunLoop, &processor);
+  StartProcessorInRunLoopArgs args;
+  args.processor = &processor;
+  args.http_fetcher = http_fetcher;
+  g_timeout_add(0, &StartProcessorInRunLoop, &args);
   g_main_loop_run(loop);
   g_main_loop_unref(loop);
 }
 }  // namespace {}
 
 TEST(DownloadActionTest, SimpleTest) {
   vector<char> small;
   const char* foo = "foo";
   small.insert(small.end(), foo, foo + strlen(foo));
   TestWithData(small,
@@ skipping 227 matching lines @@
   ActionProcessor processor;
   processor.EnqueueAction(&feeder_action);
   processor.EnqueueAction(&download_action);
   processor.StartProcessing();
   ASSERT_FALSE(processor.IsRunning());
 
   g_main_loop_unref(loop);
 }
 
 }  // namespace chromeos_update_engine