AU: Fix potential issues with premature destruction of HTTP fetchers.

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 <string>
 
 #include <base/logging.h>
@@ skipping 10 matching lines @@
 // http work.
 
 namespace chromeos_update_engine {
 
 namespace {
 const int kMaxRetriesCount = 20;
 const char kCACertificatesPath[] = "/usr/share/update_engine/ca-certificates";
 }  // namespace {}
 
 LibcurlHttpFetcher::~LibcurlHttpFetcher() {
+  LOG_IF(ERROR, transfer_in_progress_)
+      << "Destroying the fetcher while a transfer is in progress.";
   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));
@@ skipping 87 matching lines @@
 // Begins the transfer, which must not have already been started.
 void LibcurlHttpFetcher::BeginTransfer(const std::string& url) {
   transfer_size_ = -1;
   resume_offset_ = 0;
   retry_count_ = 0;
   http_response_code_ = 0;
   ResumeTransfer(url);
   CurlPerformOnce();
 }
 
+void LibcurlHttpFetcher::ForceTransferTermination() {
+  CleanUp();
+  if (delegate_) {
+    // Note that after the callback returns this object may be destroyed.
+    delegate_->TransferTerminated(this);
+  }
+}
+
 void LibcurlHttpFetcher::TerminateTransfer() {
-  if (in_write_callback_)
+  if (in_write_callback_) {
     terminate_requested_ = true;
-  else
-    CleanUp();
+  } else {
+    ForceTransferTermination();
+  }
 }
 
 void LibcurlHttpFetcher::CurlPerformOnce() {
   CHECK(transfer_in_progress_);
   int running_handles = 0;
   CURLMcode retcode = CURLM_CALL_MULTI_PERFORM;
 
   // libcurl may request that we immediately call curl_multi_perform after it
   // returns, so we do. libcurl promises that curl_multi_perform will not block.
   while (CURLM_CALL_MULTI_PERFORM == retcode) {
     retcode = curl_multi_perform(curl_multi_handle_, &running_handles);
     if (terminate_requested_) {
-      CleanUp();
+      ForceTransferTermination();
       return;
     }
   }
   if (0 == running_handles) {
     GetHttpResponseCode();
     if (http_response_code_) {
       LOG(INFO) << "HTTP response code: " << http_response_code_;
     } else {
       LOG(ERROR) << "Unable to get http response code.";
     }
@@ skipping 202 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