AU: Expose the server's HTTP response code in HttpFetcher.

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/logging.h"
@@ skipping 143 matching lines @@
 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);
     memcpy(str, bytes, length);
   }
   virtual void TransferComplete(HttpFetcher* fetcher, bool successful) {
+    EXPECT_EQ(200, fetcher->http_response_code());
     g_main_loop_quit(loop_);
   }
   GMainLoop* loop_;
 };
 
 struct StartTransferArgs {
   HttpFetcher *http_fetcher;
   string url;
 };
 
@@ skipping 151 matching lines @@
     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_);
+    EXPECT_EQ(0, fetcher->http_response_code());
   }
   g_main_loop_unref(loop);
 }
 
 namespace {
 class FlakyHttpFetcherTestDelegate : public HttpFetcherDelegate {
  public:
   virtual void ReceivedBytes(HttpFetcher* fetcher,
                              const char* bytes, int length) {
     data.append(bytes, length);
   }
   virtual void TransferComplete(HttpFetcher* fetcher, bool successful) {
     EXPECT_TRUE(successful);
+    EXPECT_EQ(206, fetcher->http_response_code());
     g_main_loop_quit(loop_);
   }
   string data;
   GMainLoop* loop_;
 };
 }  // namespace {}
 
 TYPED_TEST(HttpFetcherTest, FlakyTest) {
   if (this->IsMock())
     return;
@@ skipping 33 matching lines @@
                              const char* bytes, int length) {
     if (server_) {
       LOG(INFO) << "Stopping server";
       delete server_;
       LOG(INFO) << "server stopped";
       server_ = NULL;
     }
   }
   virtual void TransferComplete(HttpFetcher* fetcher, bool successful) {
     EXPECT_FALSE(successful);
+    EXPECT_EQ(0, fetcher->http_response_code());
     g_main_loop_quit(loop_);
   }
   GMainLoop* loop_;
   PythonHttpServer* server_;
 };
 }  // namespace {}
 
 
 TYPED_TEST(HttpFetcherTest, FailureTest) {
   if (this->IsMock())
@@ skipping 48 matching lines @@
 class RedirectHttpFetcherTestDelegate : public HttpFetcherDelegate {
  public:
   RedirectHttpFetcherTestDelegate(bool expected_successful)
       : expected_successful_(expected_successful) {}
   virtual void ReceivedBytes(HttpFetcher* fetcher,
                              const char* bytes, int length) {
     data.append(bytes, length);
   }
   virtual void TransferComplete(HttpFetcher* fetcher, bool successful) {
     EXPECT_EQ(expected_successful_, successful);
+    if (expected_successful_)
+      EXPECT_EQ(200, fetcher->http_response_code());
+    else {
+      EXPECT_GE(fetcher->http_response_code(), 301);
+      EXPECT_LE(fetcher->http_response_code(), 307);
+    }
     g_main_loop_quit(loop_);
   }
   bool expected_successful_;
   string data;
   GMainLoop* loop_;
 };
 
 // RedirectTest takes ownership of |http_fetcher|.
 void RedirectTest(bool expected_successful,
                   const string& url,
@@ skipping 55 matching lines @@
   string url;
   for (int r = 0; r < LibcurlHttpFetcher::kMaxRedirects + 1; r++) {
     url += base::StringPrintf("/redirect/%d",
                               kRedirectCodes[r % arraysize(kRedirectCodes)]);
   }
   url += "/medium";
   RedirectTest(false, url, this->NewLargeFetcher());
 }
 
 }  // namespace chromeos_update_engine