diff --git a/download_action.cc b/download_action.cc
index c17d7e2..d06fb79 100644
--- a/download_action.cc
+++ b/download_action.cc
@@ -25,6 +25,7 @@
     : prefs_(prefs),
       writer_(NULL),
       http_fetcher_(http_fetcher),
+      code_(kActionCodeSuccess),
       delegate_(NULL),
       bytes_received_(0) {}
 
@@ -101,10 +102,12 @@
     LOG_IF(WARNING, writer_->Close() != 0) << "Error closing the writer.";
     writer_ = NULL;
   }
-  http_fetcher_->TerminateTransfer();
   if (delegate_) {
     delegate_->SetDownloadStatus(false);  // Set to inactive.
   }
+  // Terminates the transfer. The action is terminated, if necessary, when the
+  // TransferTerminated callback is received.
+  http_fetcher_->TerminateTransfer();
 }
 
 void DownloadAction::SeekToOffset(off_t offset) {
@@ -119,8 +122,11 @@
     delegate_->BytesReceived(bytes_received_, install_plan_.size);
   if (writer_ && writer_->Write(bytes, length) < 0) {
     LOG(ERROR) << "Write error -- terminating processing.";
+    // Don't tell the action processor that the action is complete until we get
+    // the TransferTerminated callback. Otherwise, this and the HTTP fetcher
+    // objects may get destroyed before all callbacks are complete.
+    code_ = kActionCodeDownloadWriteError;
     TerminateProcessing();
-    processor_->ActionComplete(this, kActionCodeDownloadWriteError);
     return;
   }
   // DeltaPerformer checks the hashes for delta updates.
@@ -194,4 +200,10 @@
   processor_->ActionComplete(this, code);
 }
 
+void DownloadAction::TransferTerminated(HttpFetcher *fetcher) {
+  if (code_ != kActionCodeSuccess) {
+    processor_->ActionComplete(this, code_);
+  }
+}
+
 };  // namespace {}
diff --git a/download_action.h b/download_action.h
index d0ac175..6106740 100644
--- a/download_action.h
+++ b/download_action.h
@@ -88,6 +88,7 @@
                              const char* bytes, int length);
   virtual void SeekToOffset(off_t offset);
   virtual void TransferComplete(HttpFetcher *fetcher, bool successful);
+  virtual void TransferTerminated(HttpFetcher *fetcher);
 
   DownloadActionDelegate* delegate() const { return delegate_; }
   void set_delegate(DownloadActionDelegate* delegate) {
@@ -124,6 +125,10 @@
   // Used to find the hash of the bytes downloaded
   OmahaHashCalculator omaha_hash_calculator_;
 
+  // Used by TransferTerminated to figure if this action terminated itself or
+  // was terminated by the action processor.
+  ActionExitCode code_;
+
   // For reporting status to outsiders
   DownloadActionDelegate* delegate_;
   uint64_t bytes_received_;
diff --git a/download_action_unittest.cc b/download_action_unittest.cc
index 2f37dfb..8135841 100644
--- a/download_action_unittest.cc
+++ b/download_action_unittest.cc
@@ -49,9 +49,11 @@
     g_main_loop_quit(loop_);
     vector<char> found_data;
     ASSERT_TRUE(utils::ReadFile(path_, &found_data));
-    ASSERT_EQ(expected_data_.size(), found_data.size());
-    for (unsigned i = 0; i < expected_data_.size(); i++) {
-      EXPECT_EQ(expected_data_[i], found_data[i]);
+    if (expected_code_ != kActionCodeDownloadWriteError) {
+      ASSERT_EQ(expected_data_.size(), found_data.size());
+      for (unsigned i = 0; i < expected_data_.size(); i++) {
+        EXPECT_EQ(expected_data_[i], found_data[i]);
+      }
     }
     processing_done_called_ = true;
   }
@@ -74,6 +76,24 @@
   ActionExitCode expected_code_;
 };
 
+class TestDirectFileWriter : public DirectFileWriter {
+ public:
+  TestDirectFileWriter() : fail_write_(0), current_write_(0) {}
+  void set_fail_write(int fail_write) { fail_write_ = fail_write; }
+
+  virtual ssize_t Write(const void* bytes, size_t count) {
+    if (++current_write_ == fail_write_) {
+      return -EINVAL;
+    }
+    return DirectFileWriter::Write(bytes, count);
+  }
+
+ private:
+  // If positive, fail on the |fail_write_| call to Write.
+  int fail_write_;
+  int current_write_;
+};
+
 struct EntryPointArgs {
   const vector<char> *data;
   GMainLoop *loop;
@@ -98,12 +118,14 @@
 void TestWithData(const vector<char>& data,
                   bool hash_test,
                   bool size_test,
+                  int fail_write,
                   bool use_download_delegate) {
   GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   // TODO(adlr): see if we need a different file for build bots
   ScopedTempFile output_temp_file;
-  DirectFileWriter writer;
+  TestDirectFileWriter writer;
+  writer.set_fail_write(fail_write);
 
   // We pull off the first byte from data and seek past it.
 
@@ -134,8 +156,7 @@
     if (data.size() > kMockHttpFetcherChunkSize)
       EXPECT_CALL(download_delegate,
                   BytesReceived(1 + kMockHttpFetcherChunkSize, _));
-
-      EXPECT_CALL(download_delegate, BytesReceived(_, _)).Times(AtLeast(1));
+    EXPECT_CALL(download_delegate, BytesReceived(_, _)).Times(AtLeast(1));
     EXPECT_CALL(download_delegate, SetDownloadStatus(false)).Times(1);
   }
   ActionExitCode expected_code = kActionCodeSuccess;
@@ -143,6 +164,8 @@
     expected_code = kActionCodeDownloadHashMismatchError;
   else if (size_test)
     expected_code = kActionCodeDownloadSizeMismatchError;
+  else if (fail_write > 0)
+    expected_code = kActionCodeDownloadWriteError;
   DownloadActionTestProcessorDelegate delegate(expected_code);
   delegate.loop_ = loop;
   delegate.expected_data_ = vector<char>(data.begin() + 1, data.end());
@@ -168,6 +191,7 @@
   TestWithData(small,
                false,  // hash_test
                false,  // size_test
+               0,  // fail_write
                true);  // use_download_delegate
 }
 
@@ -176,14 +200,26 @@
   char c = '0';
   for (unsigned int i = 0; i < big.size(); i++) {
     big[i] = c;
-    if ('9' == c)
-      c = '0';
-    else
-      c++;
+    c = ('9' == c) ? '0' : c + 1;
   }
   TestWithData(big,
                false,  // hash_test
                false,  // size_test
+               0,  // fail_write
+               true);  // use_download_delegate
+}
+
+TEST(DownloadActionTest, FailWriteTest) {
+  vector<char> big(5 * kMockHttpFetcherChunkSize);
+  char c = '0';
+  for (unsigned int i = 0; i < big.size(); i++) {
+    big[i] = c;
+    c = ('9' == c) ? '0' : c + 1;
+  }
+  TestWithData(big,
+               false,  // hash_test
+               false,  // size_test
+               2,  // fail_write
                true);  // use_download_delegate
 }
 
@@ -194,6 +230,7 @@
   TestWithData(small,
                true,  // hash_test
                false,  // size_test
+               0,  // fail_write
                true);  // use_download_delegate
 }
 
@@ -203,6 +240,7 @@
   TestWithData(small,
                false,  // hash_test
                true,  // size_test
+               0,  // fail_write
                true);  // use_download_delegate
 }
 
@@ -213,6 +251,7 @@
   TestWithData(small,
                false,  // hash_test
                false,  // size_test
+               0,  // fail_write
                false);  // use_download_delegate
 }
 
diff --git a/http_fetcher.h b/http_fetcher.h
index d0f9cb2..6d8608b 100644
--- a/http_fetcher.h
+++ b/http_fetcher.h
@@ -45,11 +45,13 @@
   // Downloading should resume from this offset
   virtual void SetOffset(off_t offset) = 0;
 
-  // Begins the transfer to the specified URL.
+  // Begins the transfer to the specified URL. This fetcher instance should not
+  // be destroyed until either TransferComplete, or TransferTerminated is
+  // called.
   virtual void BeginTransfer(const std::string& url) = 0;
 
-  // Aborts the transfer. TransferComplete() will not be called on the
-  // delegate.
+  // Aborts the transfer. The transfer may not abort right away -- delegate's
+  // TransferTerminated() will be called when the transfer is actually done.
   virtual void TerminateTransfer() = 0;
 
   // If data is coming in too quickly, you can call Pause() to pause the
@@ -97,9 +99,14 @@
   // Called if the fetcher seeks to a particular offset.
   virtual void SeekToOffset(off_t offset) {}
 
-  // Called when the transfer has completed successfully or been somehow
-  // aborted.
+  // Called when the transfer has completed successfully or been aborted through
+  // means other than TerminateTransfer. It's OK to destroy the |fetcher| object
+  // in this callback.
   virtual void TransferComplete(HttpFetcher* fetcher, bool successful) = 0;
+
+  // Called when the transfer has been aborted through TerminateTransfer. It's
+  // OK to destroy the |fetcher| object in this callback.
+  virtual void TransferTerminated(HttpFetcher* fetcher) {}
 };
 
 }  // namespace chromeos_update_engine
diff --git a/http_fetcher_unittest.cc b/http_fetcher_unittest.cc
index 30cde95..87dda78 100644
--- a/http_fetcher_unittest.cc
+++ b/http_fetcher_unittest.cc
@@ -196,6 +196,9 @@
     EXPECT_EQ(200, fetcher->http_response_code());
     g_main_loop_quit(loop_);
   }
+  virtual void TransferTerminated(HttpFetcher* fetcher) {
+    ADD_FAILURE();
+  }
   GMainLoop* loop_;
 };
 
@@ -264,6 +267,9 @@
   virtual void TransferComplete(HttpFetcher* fetcher, bool successful) {
     g_main_loop_quit(loop_);
   }
+  virtual void TransferTerminated(HttpFetcher* fetcher) {
+    ADD_FAILURE();
+  }
   void Unpause() {
     CHECK(paused_);
     paused_ = false;
@@ -314,9 +320,17 @@
   virtual void ReceivedBytes(HttpFetcher* fetcher,
                              const char* bytes, int length) {}
   virtual void TransferComplete(HttpFetcher* fetcher, bool successful) {
-    CHECK(false);  // We should never get here
+    ADD_FAILURE();  // We should never get here
     g_main_loop_quit(loop_);
   }
+  virtual void TransferTerminated(HttpFetcher* fetcher) {
+    EXPECT_EQ(fetcher, fetcher_.get());
+    EXPECT_FALSE(once_);
+    EXPECT_TRUE(callback_once_);
+    callback_once_ = false;
+    // |fetcher| can be destroyed during this callback.
+    fetcher_.reset(NULL);
+ }
   void TerminateTransfer() {
     CHECK(once_);
     once_ = false;
@@ -326,7 +340,8 @@
     g_main_loop_quit(loop_);
   }
   bool once_;
-  HttpFetcher* fetcher_;
+  bool callback_once_;
+  scoped_ptr<HttpFetcher> fetcher_;
   GMainLoop* loop_;
 };
 
@@ -347,11 +362,11 @@
   GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
   {
     AbortingHttpFetcherTestDelegate delegate;
-    scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher());
+    delegate.fetcher_.reset(this->NewLargeFetcher());
     delegate.once_ = true;
+    delegate.callback_once_ = true;
     delegate.loop_ = loop;
-    delegate.fetcher_ = fetcher.get();
-    fetcher->set_delegate(&delegate);
+    delegate.fetcher_->set_delegate(&delegate);
 
     typename TestFixture::HttpServer server;
     this->IgnoreServerAborting(&server);
@@ -361,9 +376,11 @@
     g_source_set_callback(timeout_source_, AbortingTimeoutCallback, &delegate,
                           NULL);
     g_source_attach(timeout_source_, NULL);
-    fetcher->BeginTransfer(this->BigUrl());
+    delegate.fetcher_->BeginTransfer(this->BigUrl());
 
     g_main_loop_run(loop);
+    CHECK(!delegate.once_);
+    CHECK(!delegate.callback_once_);
     g_source_destroy(timeout_source_);
   }
   g_main_loop_unref(loop);
@@ -381,6 +398,9 @@
     EXPECT_EQ(206, fetcher->http_response_code());
     g_main_loop_quit(loop_);
   }
+  virtual void TransferTerminated(HttpFetcher* fetcher) {
+    ADD_FAILURE();
+  }
   string data;
   GMainLoop* loop_;
 };
@@ -435,6 +455,9 @@
     EXPECT_EQ(0, fetcher->http_response_code());
     g_main_loop_quit(loop_);
   }
+  virtual void TransferTerminated(HttpFetcher* fetcher) {
+    ADD_FAILURE();
+  }
   GMainLoop* loop_;
   PythonHttpServer* server_;
 };
@@ -509,6 +532,9 @@
     }
     g_main_loop_quit(loop_);
   }
+  virtual void TransferTerminated(HttpFetcher* fetcher) {
+    ADD_FAILURE();
+  }
   bool expected_successful_;
   string data;
   GMainLoop* loop_;
@@ -588,14 +614,22 @@
       : expected_response_code_(expected_response_code) {}
   virtual void ReceivedBytes(HttpFetcher* fetcher,
                              const char* bytes, int length) {
+    EXPECT_EQ(fetcher, fetcher_.get());
     data.append(bytes, length);
   }
   virtual void TransferComplete(HttpFetcher* fetcher, bool successful) {
+    EXPECT_EQ(fetcher, fetcher_.get());
     EXPECT_EQ(expected_response_code_ != 0, successful);
     if (expected_response_code_ != 0)
       EXPECT_EQ(expected_response_code_, fetcher->http_response_code());
+    // Destroy the fetcher (because we're allowed to).
+    fetcher_.reset(NULL);
     g_main_loop_quit(loop_);
   }
+  virtual void TransferTerminated(HttpFetcher* fetcher) {
+    ADD_FAILURE();
+  }
+  scoped_ptr<HttpFetcher> fetcher_;
   int expected_response_code_;
   string data;
   GMainLoop* loop_;
@@ -611,16 +645,16 @@
   {
     MultiHttpFetcherTestDelegate delegate(expected_response_code);
     delegate.loop_ = loop;
-    scoped_ptr<HttpFetcher> fetcher(fetcher_in);
+    delegate.fetcher_.reset(fetcher_in);
     MultiHttpFetcher<LibcurlHttpFetcher>* multi_fetcher =
-        dynamic_cast<MultiHttpFetcher<LibcurlHttpFetcher>*>(fetcher.get());
+        dynamic_cast<MultiHttpFetcher<LibcurlHttpFetcher>*>(fetcher_in);
     ASSERT_TRUE(multi_fetcher);
     multi_fetcher->set_ranges(ranges);
     multi_fetcher->SetConnectionAsExpensive(false);
     multi_fetcher->SetBuildType(false);
-    fetcher->set_delegate(&delegate);
+    multi_fetcher->set_delegate(&delegate);
 
-    StartTransferArgs start_xfer_args = {fetcher.get(), url};
+    StartTransferArgs start_xfer_args = {multi_fetcher, url};
 
     g_timeout_add(0, StartTransfer, &start_xfer_args);
     g_main_loop_run(loop);
@@ -633,7 +667,7 @@
 }
 }  // namespace {}
 
-TYPED_TEST(HttpFetcherTest, MultiHttpFetcherSimplTest) {
+TYPED_TEST(HttpFetcherTest, MultiHttpFetcherSimpleTest) {
   if (!this->IsMulti())
     return;
   typename TestFixture::HttpServer server;
@@ -713,6 +747,9 @@
     EXPECT_FALSE(successful);
     g_main_loop_quit(loop_);
   }
+  virtual void TransferTerminated(HttpFetcher* fetcher) {
+    ADD_FAILURE();
+  }
   GMainLoop* loop_;
 };
 
diff --git a/libcurl_http_fetcher.cc b/libcurl_http_fetcher.cc
index d5358bd..b65d6b1 100644
--- a/libcurl_http_fetcher.cc
+++ b/libcurl_http_fetcher.cc
@@ -28,6 +28,8 @@
 }  // namespace {}
 
 LibcurlHttpFetcher::~LibcurlHttpFetcher() {
+  LOG_IF(ERROR, transfer_in_progress_)
+      << "Destroying the fetcher while a transfer is in progress.";
   CleanUp();
 }
 
@@ -135,11 +137,20 @@
   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() {
@@ -152,7 +163,7 @@
   while (CURLM_CALL_MULTI_PERFORM == retcode) {
     retcode = curl_multi_perform(curl_multi_handle_, &running_handles);
     if (terminate_requested_) {
-      CleanUp();
+      ForceTransferTermination();
       return;
     }
   }
diff --git a/libcurl_http_fetcher.h b/libcurl_http_fetcher.h
index 3a50bda..b3ba518 100644
--- a/libcurl_http_fetcher.h
+++ b/libcurl_http_fetcher.h
@@ -48,8 +48,8 @@
   // Begins the transfer if it hasn't already begun.
   virtual void BeginTransfer(const std::string& url);
 
-  // If the transfer is in progress, aborts the transfer early.
-  // The transfer cannot be resumed.
+  // If the transfer is in progress, aborts the transfer early. The transfer
+  // cannot be resumed.
   virtual void TerminateTransfer();
 
   // Suspend the transfer by calling curl_easy_pause(CURLPAUSE_ALL).
@@ -136,6 +136,11 @@
   // curl(m) handles, io_channels_, timeout_source_.
   void CleanUp();
 
+  // Force terminate the transfer. This will invoke the delegate's (if any)
+  // TransferTerminated callback so, after returning, this fetcher instance may
+  // be destroyed.
+  void ForceTransferTermination();
+
   // Returns whether or not the current network connection is considered
   // expensive.
   bool ConnectionIsExpensive() const;
diff --git a/mock_http_fetcher.cc b/mock_http_fetcher.cc
index eec550f..1a88b94 100644
--- a/mock_http_fetcher.cc
+++ b/mock_http_fetcher.cc
@@ -41,6 +41,11 @@
                                   data_.size() - sent_size_);
     CHECK(delegate_);
     delegate_->ReceivedBytes(this, &data_[sent_size_], chunk_size);
+    // We may get terminated in the callback.
+    if (sent_size_ == data_.size()) {
+      LOG(INFO) << "Terminated in the ReceivedBytes callback.";
+      return timeout_source_;
+    }
     sent_size_ += chunk_size;
     CHECK_LE(sent_size_, data_.size());
     if (sent_size_ == data_.size()) {
@@ -81,6 +86,7 @@
 // If the transfer is in progress, aborts the transfer early.
 // The transfer cannot be resumed.
 void MockHttpFetcher::TerminateTransfer() {
+  LOG(INFO) << "Terminating transfer.";
   sent_size_ = data_.size();
   // kill any timeout
   if (timeout_source_) {
@@ -88,6 +94,7 @@
     g_source_destroy(timeout_source_);
     timeout_source_ = NULL;
   }
+  delegate_->TransferTerminated(this);
 }
 
 void MockHttpFetcher::Pause() {
diff --git a/multi_http_fetcher.h b/multi_http_fetcher.h
index 692054d..533998b 100644
--- a/multi_http_fetcher.h
+++ b/multi_http_fetcher.h
@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "update_engine/http_fetcher.h"
+#include "update_engine/utils.h"
 
 // This class is a simple wrapper around an HttpFetcher. The client
 // specifies a vector of byte ranges. MultiHttpFetcher will fetch bytes
@@ -26,6 +27,7 @@
 
   MultiHttpFetcher()
       : sent_transfer_complete_(false),
+        pending_next_fetcher_(false),
         current_index_(0),
         bytes_received_this_fetcher_(0) {}
   ~MultiHttpFetcher() {}
@@ -56,11 +58,41 @@
     StartTransfer();
   }
 
-  void TerminateTransfer() {
-    if (current_index_ < fetchers_.size())
-      fetchers_[current_index_]->TerminateTransfer();
+  void TransferTerminated(HttpFetcher* fetcher) {
+    LOG(INFO) << "Received transfer terminated.";
+    if (pending_next_fetcher_) {
+      pending_next_fetcher_ = false;
+      if (++current_index_ >= ranges_.size()) {
+        SendTransferComplete(fetcher, true);
+      } else {
+        StartTransfer();
+      }
+      return;
+    }
     current_index_ = ranges_.size();
     sent_transfer_complete_ = true;  // a fib
+    if (delegate_) {
+      // Note that after the callback returns this object may be destroyed.
+      delegate_->TransferTerminated(this);
+    }
+  }
+
+  void TerminateTransfer() {
+    // If the current fetcher is already being terminated, just wait for its
+    // TransferTerminated callback.
+    if (pending_next_fetcher_) {
+      pending_next_fetcher_ = false;
+      return;
+    }
+    // If there's a current active fetcher terminate it and wait for its
+    // TransferTerminated callback.
+    if (current_index_ < fetchers_.size()) {
+      fetchers_[current_index_]->TerminateTransfer();
+      return;
+    }
+    // Transfer is terminated before it got started and before any ranges were
+    // added.
+    TransferTerminated(this);
   }
 
   void Pause() {
@@ -127,15 +159,10 @@
     fetchers_[current_index_]->BeginTransfer(url_);
   }
 
-  void ReceivedBytes(HttpFetcher* fetcher,
-                     const char* bytes,
-                     int length) {
-    if (current_index_ >= ranges_.size())
-      return;
-    if (fetcher != fetchers_[current_index_].get()) {
-      LOG(WARNING) << "Received bytes from invalid fetcher";
-      return;
-    }
+  void ReceivedBytes(HttpFetcher* fetcher, const char* bytes, int length) {
+    TEST_AND_RETURN(current_index_ < ranges_.size());
+    TEST_AND_RETURN(fetcher == fetchers_[current_index_].get());
+    TEST_AND_RETURN(!pending_next_fetcher_);
     off_t next_size = length;
     if (ranges_[current_index_].second >= 0) {
       next_size = std::min(next_size,
@@ -149,23 +176,22 @@
     bytes_received_this_fetcher_ += length;
     if (ranges_[current_index_].second >= 0 &&
         bytes_received_this_fetcher_ >= ranges_[current_index_].second) {
-      fetchers_[current_index_]->TerminateTransfer();
-      current_index_++;
-      if (current_index_ == ranges_.size()) {
-        SendTransferComplete(fetchers_[current_index_ - 1].get(), true);
-      } else {
-        StartTransfer();
-      }
+      // Terminates the current fetcher. Waits for its TransferTerminated
+      // callback before starting the next fetcher so that we don't end up
+      // signalling the delegate that the whole multi-transfer is complete
+      // before all fetchers are really done and cleaned up.
+      pending_next_fetcher_ = true;
+      fetcher->TerminateTransfer();
     }
   }
 
   void TransferComplete(HttpFetcher* fetcher, bool successful) {
-    LOG(INFO) << "Received transfer complete";
+    TEST_AND_RETURN(!pending_next_fetcher_);
+    LOG(INFO) << "Received transfer complete.";
     if (current_index_ >= ranges_.size()) {
       SendTransferComplete(fetcher, true);
       return;
     }
-
     if (ranges_[current_index_].second < 0) {
       // We're done with the current operation
       current_index_++;
@@ -177,27 +203,28 @@
       }
       return;
     }
-
     if (bytes_received_this_fetcher_ < ranges_[current_index_].second) {
       LOG(WARNING) << "Received insufficient bytes from fetcher. "
                    << "Ending early";
       SendTransferComplete(fetcher, false);
       return;
-    } else {
-      LOG(INFO) << "Got spurious TransferComplete. Ingoring.";
     }
+    LOG(INFO) << "Got spurious TransferComplete. Ignoring.";
   }
 
   // If true, do not send any more data or TransferComplete to the delegate.
   bool sent_transfer_complete_;
 
+  // If true, the next fetcher needs to be started when TransferTerminated is
+  // received from the current fetcher.
+  bool pending_next_fetcher_;
+
   RangesVect ranges_;
   std::vector<std::tr1::shared_ptr<BaseHttpFetcher> > fetchers_;
 
   RangesVect::size_type current_index_;  // index into ranges_, fetchers_
   off_t bytes_received_this_fetcher_;
 
- private:
   DISALLOW_COPY_AND_ASSIGN(MultiHttpFetcher);
 };