Change SafeBrowsingProtocolManager::GetFullHash signature.

chrome/browser/safe_browsing/safe_browsing_service_browsertest.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.
 //
 // This test creates a safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
 #include <algorithm>
 
@@ skipping 31 matching lines @@
 #include "sql/statement.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using content::BrowserThread;
 using content::InterstitialPage;
 using content::WebContents;
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::StrictMock;
 
+namespace {
+
+void InvokeFullHashCallback(
+    SafeBrowsingProtocolManager::FullHashCallback callback,
+    const std::vector<SBFullHashResult>& result) {
+  callback.Run(result, true);
+}
+
+}  // namespace
+
 // A SafeBrowingDatabase class that allows us to inject the malicious URLs.
 class TestSafeBrowsingDatabase :  public SafeBrowsingDatabase {
  public:
   TestSafeBrowsingDatabase() {}
 
   virtual ~TestSafeBrowsingDatabase() {}
 
   // Initializes the database with the given filename.
   virtual void Init(const FilePath& filename) {}
 
@@ skipping 140 matching lines @@
 class TestProtocolManager :  public SafeBrowsingProtocolManager {
  public:
   TestProtocolManager(SafeBrowsingService* sb_service,
                       const std::string& client_name,
                       net::URLRequestContextGetter* request_context_getter,
                       const std::string& url_prefix,
                       bool disable_auto_update)
       : SafeBrowsingProtocolManager(sb_service, client_name,
                                     request_context_getter, url_prefix,
                                     disable_auto_update),
-        sb_service_(sb_service),
         delay_ms_(0) {
     create_count_++;
   }
 
   ~TestProtocolManager() {
     delete_count_++;
   }
 
   // This function is called when there is a prefix hit in local safebrowsing
   // database and safebrowsing service issues a get hash request to backends.
   // We return a result from the prefilled full_hashes_ hash_map to simulate
   // server's response. At the same time, latency is added to simulate real
   // life network issues.
-  virtual void GetFullHash(SafeBrowsingService::SafeBrowsingCheck* check,
-                           const std::vector<SBPrefix>& prefixes) {
-    // When we get a valid response, always cache the result.
-    bool cancache = true;
+  virtual void GetFullHash(
+      const std::vector<SBPrefix>& prefixes,
+      SafeBrowsingProtocolManager::FullHashCallback callback,
+      bool is_download) OVERRIDE {
     BrowserThread::PostDelayedTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&SafeBrowsingService::HandleGetHashResults,
-                   sb_service_, check, full_hashes_, cancache),
+        base::Bind(InvokeFullHashCallback, callback, full_hashes_),
         base::TimeDelta::FromMilliseconds(delay_ms_));
   }
 
   // Prepare the GetFullHash results for the next request.
   void SetGetFullHashResponse(const SBFullHashResult& full_hash_result) {
     full_hashes_.clear();
     full_hashes_.push_back(full_hash_result);
   }
 
   void IntroduceDelay(int64 ms) {
     delay_ms_ = ms;
   }
 
   static int create_count() {
     return create_count_;
   }
 
   static int delete_count() {
     return delete_count_;
   }
 
  private:
   std::vector<SBFullHashResult> full_hashes_;
-  SafeBrowsingService* sb_service_;
   int64 delay_ms_;
   static int create_count_;
   static int delete_count_;
 };
 
 // static
 int TestProtocolManager::create_count_ = 0;
 // static
 int TestProtocolManager::delete_count_ = 0;
 
@@ skipping 701 matching lines @@
 // save cookies.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceCookieTest, TestSBUpdateCookies) {
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingService>(sb_service_.get()));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingServiceCookieTest::ForceUpdate, this));
   observer.Wait();
 }