update engine: 32- and 64-bit compile

src/platform/update_engine/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 <vector>
 #include <base/scoped_ptr.h>
 #include <glib.h>
 #include <gtest/gtest.h>
@@ skipping 43 matching lines @@
     return new MockHttpFetcher("x", 1);
   }
   string BigUrl() const {
     return "unused://unused";
   }
   string SmallUrl() const {
     return "unused://unused";
   }
   bool IsMock() const { return true; }
   typedef NullHttpServer HttpServer;
+  void IgnoreServerAborting(HttpServer* server) const {}
 };
 
 class PythonHttpServer {
  public:
   PythonHttpServer() {
     char *argv[2] = {strdup("./test_http_server"), NULL};
     GError *err;
     started_ = false;
+    validate_quit_ = true;
     if (!g_spawn_async(NULL,
                        argv,
                        NULL,
                        G_SPAWN_DO_NOT_REAP_CHILD,
                        NULL,
                        NULL,
                        &pid_,
                        &err)) {
       return;
     }
     int rc = 1;
     while (0 != rc) {
       rc = system((string("wget --output-document=/dev/null ") +
                    LocalServerUrlForPath("/test")).c_str());
       usleep(10 * 1000);  // 10 ms
     }
     started_ = true;
     free(argv[0]);
     return;
   }
   ~PythonHttpServer() {
     if (!started_)
       return;
     // request that the server exit itself
-    system((string("wget --output-document=/dev/null ") +
-            LocalServerUrlForPath("/quitquitquit")).c_str());
+    int rc = system((string("wget -t 1 --output-document=/dev/null ") +
+                    LocalServerUrlForPath("/quitquitquit")).c_str());
+    if (validate_quit_)
+      EXPECT_EQ(0, rc);
     waitpid(pid_, NULL, 0);
   }
   GPid pid_;
   bool started_;
+  bool validate_quit_;
 };
 
 template <>
 class HttpFetcherTest<LibcurlHttpFetcher> : public ::testing::Test {
  public:
   HttpFetcher* NewLargeFetcher() {
     LibcurlHttpFetcher *ret = new LibcurlHttpFetcher;
     ret->set_idle_ms(1);  // speeds up test execution
     return ret;
   }
   HttpFetcher* NewSmallFetcher() {
     return NewLargeFetcher();
   }
   string BigUrl() const {
     return LocalServerUrlForPath("/big");
   }
   string SmallUrl() const {
     return LocalServerUrlForPath("/foo");
   }
   bool IsMock() const { return false; }
   typedef PythonHttpServer HttpServer;
+  void IgnoreServerAborting(HttpServer* server) const {
+    PythonHttpServer *pyserver = reinterpret_cast<PythonHttpServer*>(server);
+    pyserver->validate_quit_ = false;
+  }
 };
 
 typedef ::testing::Types<LibcurlHttpFetcher, MockHttpFetcher>
     HttpFetcherTestTypes;
 TYPED_TEST_CASE(HttpFetcherTest, HttpFetcherTestTypes);
 
 namespace {
 class HttpFetcherTestDelegate : public HttpFetcherDelegate {
  public:
   virtual void ReceivedBytes(HttpFetcher* fetcher,
@@ skipping 137 matching lines @@
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
   {
     AbortingHttpFetcherTestDelegate delegate;
     scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher());
     delegate.once_ = true;
     delegate.loop_ = loop;
     delegate.fetcher_ = fetcher.get();
     fetcher->set_delegate(&delegate);
 
     typename TestFixture::HttpServer server;
+    this->IgnoreServerAborting(&server);
     ASSERT_TRUE(server.started_);
     GSource* timeout_source_;
     timeout_source_ = g_timeout_source_new(0);  // ms
     g_source_set_callback(timeout_source_, AbortingTimeoutCallback, &delegate,
                           NULL);
     g_source_attach(timeout_source_, NULL);
     fetcher->BeginTransfer(this->BigUrl());
 
     g_main_loop_run(loop);
     g_source_destroy(timeout_source_);
@@ skipping 41 matching lines @@
     ASSERT_EQ(100000, delegate.data.size());
     for (int i = 0; i < 100000; i += 10) {
       // Assert so that we don't flood the screen w/ EXPECT errors on failure.
       ASSERT_EQ(delegate.data.substr(i, 10), "abcdefghij");
     }
   }
   g_main_loop_unref(loop);
 }
 
 }  // namespace chromeos_update_engine