AU: minor fixes requested in http://codereview.chromium.org/3010009

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 "chromeos/obsolete_logging.h"
 
 using std::max;
 using std::make_pair;
@@ skipping 61 matching lines @@
   resume_offset_ = 0;
   retry_count_ = 0;
   ResumeTransfer(url);
   CurlPerformOnce();
 }
 
 void LibcurlHttpFetcher::TerminateTransfer() {
   CleanUp();
 }
 
-bool LibcurlHttpFetcher::CurlPerformOnce() {
+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 (0 == running_handles) {
@@ skipping 16 matching lines @@
                 << bytes_downloaded_ << " bytes, but transfer_size_ is "
                 << transfer_size_ << ". retry_count: " << retry_count_;
       if (retry_count_ > kMaxRetriesCount) {
         if (delegate_)
           delegate_->TransferComplete(this, false);  // success
       } else {
         g_timeout_add(5 * 1000,
                       &LibcurlHttpFetcher::StaticRetryTimeoutCallback,
                       this);
       }
-      return false;
+      return;
     } else {
       if (delegate_) {
         // success is when http_response_code is 200
         delegate_->TransferComplete(this, http_response_code == 200);
       }
     }
   } else {
     // set up callback
     SetupMainloopSources();
   }
-  return false;
 }
 
 size_t LibcurlHttpFetcher::LibcurlWrite(void *ptr, size_t size, size_t nmemb) {
   {
     double transfer_size_double;
     CHECK_EQ(curl_easy_getinfo(curl_handle_,
                                CURLINFO_CONTENT_LENGTH_DOWNLOAD,
                                &transfer_size_double), CURLE_OK);
     off_t new_transfer_size = static_cast<off_t>(transfer_size_double);
     if (new_transfer_size > 0) {
@@ skipping 110 matching lines @@
   return true;
 }
 
 gboolean LibcurlHttpFetcher::RetryTimeoutCallback() {
   ResumeTransfer(url_);
   CurlPerformOnce();
   return FALSE;  // Don't have glib auto call this callback again
 }
 
 gboolean LibcurlHttpFetcher::TimeoutCallback() {
+  // We always return true, even if we don't want glib to cll us back.

[petkov, 2010/07/17 04:32:43]

typo: cll

+  // We will remove the event source separately if we don't want to
+  // be called back.
   if (!transfer_in_progress_)
     return TRUE;
-  // Since we will return false from this function, which tells glib to
-  // destroy the timeout callback, we must NULL it out here. This way, when
-  // setting up callback sources again, we won't try to delete this (doomed)
-  // timeout callback then.
-  // TODO(adlr): optimize by checking if we can keep this timeout callback.
-  //timeout_source_ = NULL;
   CurlPerformOnce();
   return TRUE;
 }
 
 void LibcurlHttpFetcher::CleanUp() {
   if (timeout_source_) {
     g_source_destroy(timeout_source_);
     timeout_source_ = NULL;
   }
 
@@ skipping 13 matching lines @@
     curl_handle_ = NULL;
   }
   if (curl_multi_handle_) {
     CHECK_EQ(curl_multi_cleanup(curl_multi_handle_), CURLM_OK);
     curl_multi_handle_ = NULL;
   }
   transfer_in_progress_ = false;
 }
 
 }  // namespace chromeos_update_engine