Add tests for redirect responses from SafeBrowsingProtocolManager.

chrome/browser/safe_browsing/protocol_manager.cc

 // Copyright (c) 2012 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"
 
 #ifndef NDEBUG
 #include "base/base64.h"
 #endif
 #include "base/environment.h"
@@ skipping 93 matching lines @@
     bool is_download, ResultType result_type) {
   if (is_download) {
     UMA_HISTOGRAM_ENUMERATION("SB2.GetHashResultDownload", result_type,
                               GET_HASH_RESULT_MAX);
   } else {
     UMA_HISTOGRAM_ENUMERATION("SB2.GetHashResult", result_type,
                               GET_HASH_RESULT_MAX);
   }
 }
 
+bool SafeBrowsingProtocolManager::IsUpdateScheduled() const {
+  return update_timer_.IsRunning();
+}
+
 SafeBrowsingProtocolManager::~SafeBrowsingProtocolManager() {
   // Delete in-progress SafeBrowsing requests.
   STLDeleteContainerPairFirstPointers(hash_requests_.begin(),
                                       hash_requests_.end());
   hash_requests_.clear();
 }
 
 // We can only have one update or chunk request outstanding, but there may be
 // multiple GetHash requests pending since we don't want to serialize them and
 // slow down the user.
@@ skipping 39 matching lines @@
 //              what back off / how many times to try), and if that effects the
 //              update back off. For now, a failed parse of the chunk means we
 //              drop it. This isn't so bad because the next UPDATE_REQUEST we
 //              do will report all the chunks we have. If that chunk is still
 //              required, the SafeBrowsing servers will tell us to get it again.
 void SafeBrowsingProtocolManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
   scoped_ptr<const net::URLFetcher> fetcher;
   bool parsed_ok = true;
-  bool must_back_off = false;  // Reduce SafeBrowsing service query frequency.
 
   HashRequests::iterator it = hash_requests_.find(source);
   if (it != hash_requests_.end()) {
     // GetHash response.
     fetcher.reset(it->first);
     const FullHashDetails& details = it->second;
     std::vector<SBFullHashResult> full_hashes;
     bool can_cache = false;
     if (source->GetStatus().is_success() &&
         (source->GetResponseCode() == 200 ||
@@ skipping 40 matching lines @@
     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();
+      timeout_timer_.Stop();
     }
 
     if (source->GetStatus().is_success() && source->GetResponseCode() == 200) {
       // We have data from the SafeBrowsing service.
       std::string data;
       source->GetResponseAsString(&data);
       parsed_ok = HandleServiceResponse(
           source->GetURL(), data.data(), static_cast<int>(data.length()));
       if (!parsed_ok) {
         VLOG(1) << "SafeBrowsing request for: " << source->GetURL()
                 << " failed parse.";
-        must_back_off = true;
         chunk_request_urls_.clear();
         UpdateFinished(false);
       }
 
       switch (request_type_) {
         case CHUNK_REQUEST:
-          if (parsed_ok)
+          if (parsed_ok) {
             chunk_request_urls_.pop_front();
+            if (chunk_request_urls_.empty() && !chunk_pending_to_write_)
+              UpdateFinished(true);
+          }
           break;
         case UPDATE_REQUEST:
           if (chunk_request_urls_.empty() && parsed_ok) {
             // We are up to date since the servers gave us nothing new, so we
             // are done with this update cycle.
             UpdateFinished(true);
           }
           break;
         default:
           NOTREACHED();
           break;
       }
     } else {
       // The SafeBrowsing service error, or very bad response code: back off.
-      must_back_off = true;
       if (request_type_ == CHUNK_REQUEST)
         chunk_request_urls_.clear();
       UpdateFinished(false);
       if (source->GetStatus().status() == net::URLRequestStatus::FAILED) {
         VLOG(1) << "SafeBrowsing request for: " << source->GetURL()
                 << " failed with error: " << source->GetStatus().error();
       } else {
         VLOG(1) << "SafeBrowsing request for: " << source->GetURL()
                 << " failed with error: " << source->GetResponseCode();
       }
     }
   }
 
-  // Schedule a new update request if we've finished retrieving all the chunks
-  // from the previous update. We treat the update request and the chunk URLs it
-  // contains as an atomic unit as far as back off is concerned.
-  if (chunk_request_urls_.empty() &&
-      (request_type_ == CHUNK_REQUEST || request_type_ == UPDATE_REQUEST))
-    ScheduleNextUpdate(must_back_off);
-
   // Get the next chunk if available.
   IssueChunkRequest();
 }
 
 bool SafeBrowsingProtocolManager::HandleServiceResponse(const GURL& url,
                                                         const char* data,
                                                         int length) {
   DCHECK(CalledOnValidThread());
   SafeBrowsingProtocolParser parser;
 
@@ skipping 65 matching lines @@
         VLOG(1) << "ParseChunk error for chunk: " << chunk_url.url
                 << ", Base64Encode(data): " << encoded_chunk
                 << ", length: " << length;
 #endif
         return false;
       }
 
       // Chunks to add to storage.  Pass ownership of |chunks|.
       if (!chunks->empty()) {
         chunk_pending_to_write_ = true;
-        delegate_->AddChunks(chunk_url.list_name, chunks.release());
+        delegate_->AddChunks(
+            chunk_url.list_name, chunks.release(),
+            base::Bind(&SafeBrowsingProtocolManager::OnAddChunksComplete,
+                       base::Unretained(this)));
       }
 
       break;
     }
 
     default:
       return false;
   }
 
   return true;
@@ skipping 100 matching lines @@
   request_->SetRequestContext(request_context_getter_);
   chunk_request_start_ = base::Time::Now();
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::OnGetChunksComplete(
     const std::vector<SBListChunkRanges>& lists, bool database_error) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(request_type_, UPDATE_REQUEST);
   if (database_error) {
-    UpdateFinished(false);
-    ScheduleNextUpdate(false);
+    // The update was not successful, but don't back off.
+    UpdateFinished(false, false);
     return;
   }
 
   // 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) {
     list_data.append(FormatList(lists[i]));
     if (lists[i].name == safe_browsing_util::kPhishingList)
@@ skipping 15 matching lines @@
 
   GURL update_url = UpdateUrl();
   request_.reset(net::URLFetcher::Create(
       url_fetcher_id_++, update_url, net::URLFetcher::POST, this));
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_);
   request_->SetUploadData("text/plain", list_data);
   request_->Start();
 
   // Begin the update request timeout.
-  update_timer_.Start(FROM_HERE, TimeDelta::FromSeconds(kSbMaxUpdateWaitSec),
-                      this,
-                      &SafeBrowsingProtocolManager::UpdateResponseTimeout);
+  timeout_timer_.Start(FROM_HERE, 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(CalledOnValidThread());
   DCHECK_EQ(request_type_, UPDATE_REQUEST);
   request_.reset();
   UpdateFinished(false);
-  ScheduleNextUpdate(true);
 }
 
-void SafeBrowsingProtocolManager::OnChunkInserted() {
+void SafeBrowsingProtocolManager::OnAddChunksComplete() {
   DCHECK(CalledOnValidThread());
   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 18 matching lines @@
 }
 
 void SafeBrowsingProtocolManager::HandleGetHashError(const Time& now) {
   DCHECK(CalledOnValidThread());
   base::TimeDelta next = GetNextBackOffInterval(
       &gethash_error_count_, &gethash_back_off_mult_);
   next_gethash_time_ = now + next;
 }
 
 void SafeBrowsingProtocolManager::UpdateFinished(bool success) {
+  UpdateFinished(success, !success);
+}
+
+void SafeBrowsingProtocolManager::UpdateFinished(bool success, bool back_off) {
   DCHECK(CalledOnValidThread());
   UMA_HISTOGRAM_COUNTS("SB2.UpdateSize", update_size_);
   update_size_ = 0;
   delegate_->UpdateFinished(success);
+  ScheduleNextUpdate(back_off);
 }
 
 GURL SafeBrowsingProtocolManager::UpdateUrl() const {
   std::string url = SafeBrowsingProtocolManagerHelper::ComposeUrl(
       url_prefix_, "downloads", client_name_, version_, additional_query_);
   return GURL(url);
 }
 
 GURL SafeBrowsingProtocolManager::GetHashUrl() const {
   std::string url = SafeBrowsingProtocolManagerHelper::ComposeUrl(
@@ skipping 35 matching lines @@
     FullHashCallback callback, bool is_download)
     : callback(callback),
       is_download(is_download) {
 }
 
 SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {
 }
 
 SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {
 }