AU: Don't use network on expensive connection types

libcurl_http_fetcher.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 "update_engine/libcurl_http_fetcher.h"
+
 #include <algorithm>
-#include "base/logging.h"
+#include <string>
+
+#include <base/logging.h>
+
+#include "update_engine/dbus_interface.h"
+#include "update_engine/flimflam_proxy.h"
+#include "update_engine/utils.h"
 
 using std::max;
 using std::make_pair;
+using std::string;
 
 // This is a concrete implementation of HttpFetcher that uses libcurl to do the
 // http work.
 
 namespace chromeos_update_engine {
 
 namespace {
 const int kMaxRetriesCount = 20;
 const char kCACertificatesPath[] = "/usr/share/update_engine/ca-certificates";
-}
+}  // namespace {}
 
 LibcurlHttpFetcher::~LibcurlHttpFetcher() {
   CleanUp();
 }
 
+// On error, returns false.
+bool LibcurlHttpFetcher::ConnectionIsExpensive() const {
+  if (force_connection_type_)
+    return forced_expensive_connection_;
+  NetworkConnectionType type;
+  ConcreteDbusGlib dbus_iface;
+  TEST_AND_RETURN_FALSE(FlimFlamProxy::GetConnectionType(&dbus_iface, &type));
+  LOG(INFO) << "We are connected via "
+            << FlimFlamProxy::StringForConnectionType(type);
+  return FlimFlamProxy::IsExpensiveConnectionType(type);
+}
+
 void LibcurlHttpFetcher::ResumeTransfer(const std::string& url) {
   LOG(INFO) << "Starting/Resuming transfer";
   CHECK(!transfer_in_progress_);
   url_ = url;
   curl_multi_handle_ = curl_multi_init();
   CHECK(curl_multi_handle_);
 
   curl_handle_ = curl_easy_init();
   CHECK(curl_handle_);
 
@@ skipping 11 matching lines @@
     // Resume from where we left off
     resume_offset_ = bytes_downloaded_;
     CHECK_EQ(curl_easy_setopt(curl_handle_,
                               CURLOPT_RESUME_FROM_LARGE,
                               bytes_downloaded_), CURLE_OK);
   }
 
   CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_WRITEDATA, this), CURLE_OK);
   CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_WRITEFUNCTION,
                             StaticLibcurlWrite), CURLE_OK);
-  CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_URL, url_.c_str()), CURLE_OK);
+
+  string url_to_use(url_);
+  if (ConnectionIsExpensive()) {

[petkov, 2010/10/21 05:15:19]

If the device switches from WiFi to 3G in the middle of a download, does the
connection always fail (as reported by libcurl) so we go through resume again?

[adlr, 2010/10/21 19:41:14]

This code path is called for every connection or reconnection attempt. So if we
switch connection types midway through a download, it'll handle it properly.

+    LOG(INFO) << "Not initiating HTTP connection b/c we are on an expensive"
+              << " connection";
+    url_to_use = "";  // Sabotage the URL
+  }
+
+  CHECK_EQ(curl_easy_setopt(curl_handle_,
+                            CURLOPT_URL,
+                            url_to_use.c_str()),
+           CURLE_OK);
 
   // If the connection drops under 10 bytes/sec for 3 minutes, reconnect.
   CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_LOW_SPEED_LIMIT, 10),
            CURLE_OK);
   CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_LOW_SPEED_TIME, 3 * 60),
            CURLE_OK);
 
   // By default, libcurl doesn't follow redirections. Allow up to
   // |kMaxRedirects| redirections.
   CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_FOLLOWLOCATION, 1), CURLE_OK);
@@ skipping 235 matching lines @@
 void LibcurlHttpFetcher::GetHttpResponseCode() {
   long http_response_code = 0;
   if (curl_easy_getinfo(curl_handle_,
                         CURLINFO_RESPONSE_CODE,
                         &http_response_code) == CURLE_OK) {
     http_response_code_ = static_cast<int>(http_response_code);
   }
 }
 
 }  // namespace chromeos_update_engine