Add tests for redirect responses from SafeBrowsingProtocolManager.

chrome/browser/safe_browsing/safe_browsing_service.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/safe_browsing_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 511 matching lines @@
 
 void SafeBrowsingService::GetChunks(GetChunksCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   DCHECK(!callback.is_null());
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
       &SafeBrowsingService::GetAllChunksFromDatabase, this, callback));
 }
 
 void SafeBrowsingService::AddChunks(const std::string& list,
-                                    SBChunkList* chunks) {
+                                    SBChunkList* chunks,
+                                    AddChunksCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
-      &SafeBrowsingService::HandleChunkForDatabase, this, list, chunks));
+      &SafeBrowsingService::HandleChunkForDatabase, this, list, chunks,
+      callback));
 }
 
 void SafeBrowsingService::DeleteChunks(
     std::vector<SBChunkDelete>* chunk_deletes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
       &SafeBrowsingService::DeleteDatabaseChunks, this, chunk_deletes));
 }
 
@@ skipping 348 matching lines @@
 }
 
 void SafeBrowsingService::OnGetAllChunksFromDatabase(
     const std::vector<SBListChunkRanges>& lists, bool database_error,
     GetChunksCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (enabled_)
     callback.Run(lists, database_error);
 }
 
-void SafeBrowsingService::OnChunkInserted() {
+void SafeBrowsingService::OnAddChunksComplete(AddChunksCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (enabled_)
-    protocol_manager_->OnChunkInserted();
+    callback.Run();
 }
 
 void SafeBrowsingService::DatabaseLoadComplete() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!enabled_)
     return;
 
   HISTOGRAM_COUNTS("SB.QueueDepth", queued_checks_.size());
   if (queued_checks_.empty())
     return;
@@ skipping 13 matching lines @@
       sb_check.urls.push_back(check.url);
       sb_check.client = check.client;
       sb_check.threat_type = SB_THREAT_TYPE_SAFE;
       check.client->OnSafeBrowsingResult(sb_check);
     }
     queued_checks_.pop_front();
   }
 }
 
 void SafeBrowsingService::HandleChunkForDatabase(
-    const std::string& list_name, SBChunkList* chunks) {
+    const std::string& list_name, SBChunkList* chunks,
+    AddChunksCallback callback) {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   if (chunks) {
     GetDatabase()->InsertChunks(list_name, *chunks);
     delete chunks;
   }
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&SafeBrowsingService::OnChunkInserted, this));
+      base::Bind(&SafeBrowsingService::OnAddChunksComplete, this, callback));
 }
 
 void SafeBrowsingService::DeleteDatabaseChunks(
     std::vector<SBChunkDelete>* chunk_deletes) {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   if (chunk_deletes) {
     GetDatabase()->DeleteChunks(*chunk_deletes);
     delete chunk_deletes;
   }
 }
@@ skipping 483 matching lines @@
     Stop();
 
   if (csd_service_.get())
     csd_service_->SetEnabledAndRefreshState(enable);
   if (download_service_.get()) {
     download_service_->SetEnabled(
         enable && !CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kDisableImprovedDownloadProtection));
   }
 }