Change SafeBrowsingProtocolManager::GetFullHash signature.

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 116 matching lines @@
                              safebrowsing_reports_.end());
   safebrowsing_reports_.clear();
 }
 
 // Public API used by the SafeBrowsingService ----------------------------------
 
 // 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.
 void SafeBrowsingProtocolManager::GetFullHash(
-    SafeBrowsingService::SafeBrowsingCheck* check,
-    const std::vector<SBPrefix>& prefixes) {
+    const std::vector<SBPrefix>& prefixes,
+    FullHashCallback callback,
+    bool is_download) {
   // If we are in GetHash backoff, we need to check if we're past the next
   // allowed time. If we are, we can proceed with the request. If not, we are
   // required to return empty results (i.e. treat the page as safe).
   if (gethash_error_count_ && Time::Now() <= next_gethash_time_) {
     std::vector<SBFullHashResult> full_hashes;
-    sb_service_->HandleGetHashResults(check, full_hashes, false);
+    callback.Run(full_hashes, false);
     return;
   }
   GURL gethash_url = GetHashUrl();
   net::URLFetcher* fetcher = net::URLFetcher::Create(
       gethash_url, net::URLFetcher::POST, this);
-  hash_requests_[fetcher] = check;
+  hash_requests_[fetcher] = FullHashDetails(callback, is_download);
 
   std::string get_hash;
   SafeBrowsingProtocolParser parser;
   parser.FormatGetHash(prefixes, &get_hash);
 
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_);
   fetcher->SetUploadData("text/plain", get_hash);
   fetcher->Start();
 }
@@ skipping 27 matching lines @@
     const net::URLFetcher* report = *sit;
     safebrowsing_reports_.erase(sit);
     delete report;
     return;
   }
 
   HashRequests::iterator it = hash_requests_.find(source);
   if (it != hash_requests_.end()) {
     // GetHash response.
     fetcher.reset(it->first);
-    SafeBrowsingService::SafeBrowsingCheck* check = it->second;
+    const FullHashDetails& details = it->second;
     std::vector<SBFullHashResult> full_hashes;
     bool can_cache = false;
     if (source->GetStatus().is_success() &&
         (source->GetResponseCode() == 200 ||
          source->GetResponseCode() == 204)) {
       // For tracking our GetHash false positive (204) rate, compared to real
       // (200) responses.
       if (source->GetResponseCode() == 200)
-        RecordGetHashResult(check->is_download, GET_HASH_STATUS_200);
+        RecordGetHashResult(details.is_download, GET_HASH_STATUS_200);
       else
-        RecordGetHashResult(check->is_download, GET_HASH_STATUS_204);
+        RecordGetHashResult(details.is_download, GET_HASH_STATUS_204);
       can_cache = true;
       gethash_error_count_ = 0;
       gethash_back_off_mult_ = 1;
       SafeBrowsingProtocolParser parser;
       std::string data;
       source->GetResponseAsString(&data);
       parsed_ok = parser.ParseGetHash(
           data.data(),
           static_cast<int>(data.length()),
           &full_hashes);
@@ skipping 10 matching lines @@
                 << " failed with error: " << source->GetStatus().error();
       } else {
         VLOG(1) << "SafeBrowsing GetHash request for: " << source->GetURL()
                 << " failed with error: " << source->GetResponseCode();
       }
     }
 
     // Call back the SafeBrowsingService with full_hashes, even if there was a
     // parse error or an error response code (in which case full_hashes will be
     // empty). We can't block the user regardless of the error status.
-    sb_service_->HandleGetHashResults(check, full_hashes, can_cache);
+    details.callback.Run(full_hashes, can_cache);
 
     hash_requests_.erase(it);
   } else {
     // Update or chunk response.
     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.
@@ skipping 485 matching lines @@
   if (!additional_query_.empty()) {
     if (next_url.find("?") != std::string::npos) {
       next_url.append("&");
     } else {
       next_url.append("?");
     }
     next_url.append(additional_query_);
   }
   return GURL(next_url);
 }
+
+SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails()
+    : callback(),
+      is_download(false) {
+}
+
+SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails(
+    FullHashCallback callback, bool is_download)
+    : callback(callback),
+      is_download(is_download) {
+}
+
+SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {
+}