Fix for an "update in progress" DCHECK

chrome/browser/safe_browsing/protocol_manager.cc

 // Copyright (c) 2006-2008 The Chromium 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 "chrome/browser/safe_browsing/protocol_manager.h"
 
 #include "base/file_version_info.h"
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 10 matching lines @@
 #include "net/base/base64.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 
 using base::Time;
 using base::TimeDelta;
 
 // Maximum time, in seconds, from start up before we must issue an update query.
 static const int kSbTimerStartIntervalSec = 5 * 60;
 
+// The maximum time, in seconds, to wait for a response to an update request.
+static const int kSbMaxUpdateWaitSec = 10;
+
 // Update URL for querying about the latest set of chunk updates.
 static const char* const kSbUpdateUrl =
     "http://safebrowsing.clients.google.com/safebrowsing/downloads?client=%s"
     "&appver=%s&pver=2.2";
 
 // GetHash request URL for retrieving full hashes.
 static const char* const kSbGetHashUrl =
     "http://safebrowsing.clients.google.com/safebrowsing/gethash?client=%s"
     "&appver=%s&pver=2.2";
 
@@ skipping 187 matching lines @@
     }
 
     // Call back the SafeBrowsingService with full_hashes, even if there was a
     // parse error or an error response code (in which case full_hashes will be
     // empty). We can't block the user regardless of the error status.
     sb_service_->HandleGetHashResults(check, full_hashes, can_cache);
 
     hash_requests_.erase(it);
   } else {
     // Update, chunk or key response.
-    DCHECK(source == request_.get());
     fetcher.reset(request_.release());
 
+    if (request_type_ == UPDATE_REQUEST) {
+      if (!fetcher.get()) {
+        // We've timed out waiting for an update response, so we've cancelled
+        // the update request and scheduled a new one. Ignore this response.
+        return;
+      }
+
+      // Cancel the update response timeout now that we have the response.
+      update_timer_.Stop();
+    }
+
     if (response_code == 200) {
       // We have data from the SafeBrowsing service.
       parsed_ok = HandleServiceResponse(source->url(),
                                         data.data(),
                                         static_cast<int>(data.length()));
       if (!parsed_ok) {
         SB_DLOG(INFO) << "SafeBrowsing request for: " << source->url()
                       << "failed parse.";
         must_back_off = true;
         chunk_request_urls_.clear();
@@ skipping 266 matching lines @@
   request_->set_request_context(Profile::GetDefaultRequestContext());
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::OnGetChunksComplete(
     const std::vector<SBListChunkRanges>& lists, bool database_error) {
   DCHECK(request_type_ == UPDATE_REQUEST);
 
   if (database_error) {
     ScheduleNextUpdate(false);
+    UpdateFinished(false);
     return;
   }
 
   const bool use_mac = !client_key_.empty();
 
   // Format our stored chunks:
   std::string list_data;
   bool found_malware = false;
   bool found_phishing = false;
   for (size_t i = 0; i < lists.size(); ++i) {
@@ skipping 22 matching lines @@
     url.append("&wrkey=");
     url.append(wrapped_key_);
   }
 
   GURL update_url(url);
   request_.reset(new URLFetcher(update_url, URLFetcher::POST, this));
   request_->set_load_flags(net::LOAD_DISABLE_CACHE);
   request_->set_request_context(Profile::GetDefaultRequestContext());
   request_->set_upload_data("text/plain", list_data);
   request_->Start();
+
+  // Begin the update request timeout.
+  update_timer_.Start(TimeDelta::FromSeconds(kSbMaxUpdateWaitSec), this,
+                      &SafeBrowsingProtocolManager::UpdateResponseTimeout);
+}
+
+// If we haven't heard back from the server with an update response, this method
+// will run. Close the current update session and schedule another update.
+void SafeBrowsingProtocolManager::UpdateResponseTimeout() {
+  DCHECK(request_type_ == UPDATE_REQUEST);
+  request_.reset();
+  ScheduleNextUpdate(false);
+  UpdateFinished(false);
 }
 
 void SafeBrowsingProtocolManager::OnChunkInserted() {
   chunk_pending_to_write_ = false;
 
   if (chunk_request_urls_.empty()) {
     UMA_HISTOGRAM_LONG_TIMES("SB2.Update", Time::Now() - last_update_);
     UpdateFinished(true);
   } else {
     IssueChunkRequest();
@@ skipping 50 matching lines @@
 void SafeBrowsingProtocolManager::HandleGetHashError(const Time& now) {
   int next = GetNextBackOffTime(&gethash_error_count_, &gethash_back_off_mult_);
   next_gethash_time_ = now + TimeDelta::FromSeconds(next);
 }
 
 void SafeBrowsingProtocolManager::UpdateFinished(bool success) {
   UMA_HISTOGRAM_COUNTS("SB2.UpdateSize", update_size_);
   update_size_ = 0;
   sb_service_->UpdateFinished(success);
 }