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 232 matching lines @@
       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();
@@ skipping 11 matching lines @@
       } 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))
+  if (chunk_request_urls_.empty() && !chunk_pending_to_write_ &&

[mattm, 2012/11/16 21:48:46]

so if we hit this case, does something else schedule the next update once the
chunk is written?  Is there a test of this case?

[cbentzel, 2012/11/16 21:52:35]

This is handled in OnAddChunksComplete.

The test that I added - SafeBrowsingProtocolManagerTest.ChunksRedirectResponse 
and related ones - test this case.

+      (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 66 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 152 matching lines @@
 // 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 77 matching lines @@
     FullHashCallback callback, bool is_download)
     : callback(callback),
       is_download(is_download) {
 }
 
 SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {
 }
 
 SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {
 }