AU: Restrict to HTTPS for official builds.

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>
 
@@ skipping 118 matching lines @@
 
 template <>
 class HttpFetcherTest<LibcurlHttpFetcher> : public ::testing::Test {
  public:
   virtual HttpFetcher* NewLargeFetcher() {
     LibcurlHttpFetcher *ret = new LibcurlHttpFetcher;
     // 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");
@@ skipping 13 matching lines @@
  public:
   HttpFetcher* NewLargeFetcher() {
     MultiHttpFetcher<LibcurlHttpFetcher> *ret =
         new MultiHttpFetcher<LibcurlHttpFetcher>;
     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; }
 };
 
 typedef ::testing::Types<LibcurlHttpFetcher,
                          MockHttpFetcher,
                          MultiHttpFetcher<LibcurlHttpFetcher> >
 HttpFetcherTestTypes;
 TYPED_TEST_CASE(HttpFetcherTest, HttpFetcherTestTypes);
@@ skipping 424 matching lines @@
                int expected_response_code) {
   GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   {
     MultiHttpFetcherTestDelegate delegate(expected_response_code);
     delegate.loop_ = loop;
     scoped_ptr<HttpFetcher> fetcher(fetcher_in);
     MultiHttpFetcher<LibcurlHttpFetcher>* multi_fetcher =
         dynamic_cast<MultiHttpFetcher<LibcurlHttpFetcher>*>(fetcher.get());
     ASSERT_TRUE(multi_fetcher);
     multi_fetcher->set_ranges(ranges);
+    multi_fetcher->SetConnectionAsExpensive(false);
+    multi_fetcher->SetBuildType(false);
     fetcher->set_delegate(&delegate);
 
     StartTransferArgs start_xfer_args = {fetcher.get(), 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()));
@@ skipping 65 matching lines @@
               this->BigUrl(),
               ranges,
               "ij",
               2,
               0);
     ranges.push_back(make_pair(0, 5));
   }
 }
 
 namespace {
-class ExpensiveConnectionTestDelegate : public HttpFetcherDelegate {
+class BlockedTransferTestDelegate : public HttpFetcherDelegate {
  public:
   virtual void ReceivedBytes(HttpFetcher* fetcher,
                              const char* bytes, int length) {
     ADD_FAILURE();
   }
   virtual void TransferComplete(HttpFetcher* fetcher, bool successful) {
     EXPECT_FALSE(successful);
     g_main_loop_quit(loop_);
   }
   GMainLoop* loop_;
 };
 
 }  // namespace
 
-TYPED_TEST(HttpFetcherTest, ExpensiveConnectionTest) {
+TYPED_TEST(HttpFetcherTest, BlockedTransferTest) {
   if (this->IsMock() || this->IsMulti())
     return;
-  typename TestFixture::HttpServer server;
-  
-  ASSERT_TRUE(server.started_);
 
-  GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
-  ExpensiveConnectionTestDelegate delegate;
-  delegate.loop_ = loop;
+  for (int i = 0; i < 2; i++) {
+    typename TestFixture::HttpServer server;
 
-  scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher());
-  dynamic_cast<LibcurlHttpFetcher*>(
-      fetcher.get())->SetConnectionAsExpensive(true);
-  fetcher->set_delegate(&delegate);
+    ASSERT_TRUE(server.started_);
 
-  StartTransferArgs start_xfer_args =
-      { fetcher.get(), LocalServerUrlForPath(this->SmallUrl()) };
+    GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
+    BlockedTransferTestDelegate delegate;
+    delegate.loop_ = loop;
 
-  g_timeout_add(0, StartTransfer, &start_xfer_args);
-  g_main_loop_run(loop);
-  g_main_loop_unref(loop);
+    scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher());
+    LibcurlHttpFetcher* curl_fetcher =
+        dynamic_cast<LibcurlHttpFetcher*>(fetcher.get());
+    bool is_expensive_connection = (i == 0);
+    bool is_official_build = (i == 1);
+    LOG(INFO) << "is_expensive_connection: " << is_expensive_connection;
+    LOG(INFO) << "is_official_build: " << is_official_build;
+    curl_fetcher->SetConnectionAsExpensive(is_expensive_connection);
+    curl_fetcher->SetBuildType(is_official_build);
+    fetcher->set_delegate(&delegate);
+
+    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