Add tests for redirect responses from SafeBrowsingProtocolManager.

chrome/browser/safe_browsing/database_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/database_manager.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 299 matching lines @@
 
 void SafeBrowsingDatabaseManager::GetChunks(GetChunksCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   DCHECK(!callback.is_null());
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
       &SafeBrowsingDatabaseManager::GetAllChunksFromDatabase, this, callback));
 }
 
 void SafeBrowsingDatabaseManager::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(
-      &SafeBrowsingDatabaseManager::HandleChunkForDatabase, this, list,
-      chunks));
+      &SafeBrowsingDatabaseManager::AddDatabaseChunks, this, list,
+      chunks, callback));
 }
 
 void SafeBrowsingDatabaseManager::DeleteChunks(
     std::vector<SBChunkDelete>* chunk_deletes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
       &SafeBrowsingDatabaseManager::DeleteDatabaseChunks, this, chunk_deletes));
 }
 
@@ skipping 258 matching lines @@
 }
 
 void SafeBrowsingDatabaseManager::OnGetAllChunksFromDatabase(
     const std::vector<SBListChunkRanges>& lists, bool database_error,
     GetChunksCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (enabled_)
     callback.Run(lists, database_error);
 }
 
-void SafeBrowsingDatabaseManager::OnChunkInserted() {
+void SafeBrowsingDatabaseManager::OnAddChunksComplete(
+    AddChunksCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (enabled_)
-    sb_service_->protocol_manager()->OnChunkInserted();
+    callback.Run();
 }
 
 void SafeBrowsingDatabaseManager::DatabaseLoadComplete() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!enabled_)
     return;
 
   HISTOGRAM_COUNTS("SB.QueueDepth", queued_checks_.size());
   if (queued_checks_.empty())
     return;
@@ skipping 12 matching lines @@
       SafeBrowsingCheck sb_check;
       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 SafeBrowsingDatabaseManager::HandleChunkForDatabase(
-    const std::string& list_name, SBChunkList* chunks) {
+void SafeBrowsingDatabaseManager::AddDatabaseChunks(
+    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(&SafeBrowsingDatabaseManager::OnChunkInserted, this));
+      base::Bind(&SafeBrowsingDatabaseManager::OnAddChunksComplete, this,
+                 callback));
 }
 
 void SafeBrowsingDatabaseManager::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 228 matching lines @@
       new base::WeakPtrFactory<SafeBrowsingDatabaseManager>(this));
   checks_.insert(check);
 
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, task);
 
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManager::TimeoutCallback,
                  check->timeout_factory_->GetWeakPtr(), check),
       base::TimeDelta::FromMilliseconds(timeout_ms));
 }