Add switches and apis in safebrowsing code to allow tests.

chrome/browser/safe_browsing/protocol_manager.cc

 // Copyright (c) 2010 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"
 
 #include "base/base64.h"
 #include "base/env_var.h"
 #include "base/file_version_info.h"
 #include "base/histogram.h"
@@ skipping 16 matching lines @@
 
 using base::Time;
 using base::TimeDelta;
 
 // Maximum time, in seconds, from start up before we must issue an update query.
 static const int kSbTimerStartIntervalSec = 5 * 60;
 
 // The maximum time, in seconds, to wait for a response to an update request.
 static const int kSbMaxUpdateWaitSec = 10;
 
-// Update URL for querying about the latest set of chunk updates.
-static const char* const kSbUpdateUrl =
-    "http://safebrowsing.clients.google.com/safebrowsing/downloads?client=%s"
-    "&appver=%s&pver=2.2";
-
-// GetHash request URL for retrieving full hashes.
-static const char* const kSbGetHashUrl =
-    "http://safebrowsing.clients.google.com/safebrowsing/gethash?client=%s"
-    "&appver=%s&pver=2.2";
-
-// New MAC client key requests URL.
-static const char* const kSbNewKeyUrl =
-    "https://sb-ssl.google.com/safebrowsing/newkey?client=%s&appver=%s"
-    "&pver=2.2";
-
-// URL for reporting malware pages.
-static const char* const kSbMalwareReportUrl =
-    "http://safebrowsing.clients.google.com/safebrowsing/report?evts=malblhit"
-    "&evtd=%s&evtr=%s&evhr=%s&client=%s&appver=%s";
-
 // Maximum back off multiplier.
 static const int kSbMaxBackOff = 8;
 
 
 // SafeBrowsingProtocolManager implementation ----------------------------------
 
 SafeBrowsingProtocolManager::SafeBrowsingProtocolManager(
     SafeBrowsingService* sb_service,
     const std::string& client_name,
     const std::string& client_key,
     const std::string& wrapped_key,
-    URLRequestContextGetter* request_context_getter)
+    URLRequestContextGetter* request_context_getter,
+    const std::string& info_url_prefix,
+    const std::string& mackey_url_prefix,
+    bool disable_auto_update)
     : sb_service_(sb_service),
       request_type_(NO_REQUEST),
       update_error_count_(0),
       gethash_error_count_(0),
       update_back_off_mult_(1),
       gethash_back_off_mult_(1),
       next_update_sec_(-1),
       update_state_(FIRST_REQUEST),
       initial_request_(true),
       chunk_pending_to_write_(false),
       client_key_(client_key),
       wrapped_key_(wrapped_key),
       update_size_(0),
       client_name_(client_name),
-      request_context_getter_(request_context_getter) {
+      request_context_getter_(request_context_getter),
+      info_url_prefix_(info_url_prefix),
+      mackey_url_prefix_(mackey_url_prefix),
+      disable_auto_update_(disable_auto_update) {
+  DCHECK(!info_url_prefix_.empty() && !mackey_url_prefix_.empty());
+
   // Set the backoff multiplier fuzz to a random value between 0 and 1.
   back_off_fuzz_ = static_cast<float>(base::RandDouble());
-
   // The first update must happen between 1-5 minutes of start up.
   next_update_sec_ = base::RandInt(60, kSbTimerStartIntervalSec);
 
-  scoped_ptr<FileVersionInfo> version_info(
-      chrome_app::GetChromeVersionInfo());
+  scoped_ptr<FileVersionInfo> version_info(chrome_app::GetChromeVersionInfo());
   if (!version_info.get())
     version_ = "0.1";
   else
     version_ = WideToASCII(version_info->product_version());
 }
 
 SafeBrowsingProtocolManager::~SafeBrowsingProtocolManager() {
   // Delete in-progress SafeBrowsing requests.
   STLDeleteContainerPairFirstPointers(hash_requests_.begin(),
                                       hash_requests_.end());
@@ skipping 13 matching lines @@
     SafeBrowsingService::SafeBrowsingCheck* check,
     const std::vector<SBPrefix>& prefixes) {
   // 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);
     return;
   }
-
-  std::string url = StringPrintf(kSbGetHashUrl,
-                                 client_name_.c_str(),
-                                 version_.c_str());
-  if (!client_key_.empty()) {
-    url.append("&wrkey=");
-    url.append(wrapped_key_);
-  }
-
-  GURL gethash_url(url);
+  bool use_mac = !client_key_.empty();
+  GURL gethash_url = GetHashUrl(use_mac);
   URLFetcher* fetcher = new URLFetcher(gethash_url, URLFetcher::POST, this);
   hash_requests_[fetcher] = check;
 
   std::string get_hash;
   SafeBrowsingProtocolParser parser;
   parser.FormatGetHash(prefixes, &get_hash);
 
   fetcher->set_load_flags(net::LOAD_DISABLE_CACHE);
   fetcher->set_request_context(request_context_getter_);
   fetcher->set_upload_data("text/plain", get_hash);
@@ skipping 296 matching lines @@
 void SafeBrowsingProtocolManager::Initialize() {
   // Don't want to hit the safe browsing servers on build/chrome bots.
   scoped_ptr<base::EnvVarGetter> env(base::EnvVarGetter::Create());
   if (env->HasEnv(env_vars::kHeadless))
     return;
 
   ScheduleNextUpdate(false /* no back off */);
 }
 
 void SafeBrowsingProtocolManager::ScheduleNextUpdate(bool back_off) {
-  DCHECK(next_update_sec_ > 0);
+  DCHECK_GT(next_update_sec_, 0);
 
+  if (disable_auto_update_) {
+    // Unschedule any current timer.
+    update_timer_.Stop();
+    return;
+  }
+  // Reschedule with the new update.
+  const int next_update = GetNextUpdateTime(back_off);
+  ForceScheduleNextUpdate(next_update);
+}
+
+void SafeBrowsingProtocolManager::ForceScheduleNextUpdate(
+    const int next_update_msec) {
+  DCHECK_GE(next_update_msec, 0);
   // Unschedule any current timer.
   update_timer_.Stop();
-
-  // Reschedule with the new update.
-  const int next_update = GetNextUpdateTime(back_off);
-  update_timer_.Start(TimeDelta::FromMilliseconds(next_update), this,
+  update_timer_.Start(TimeDelta::FromMilliseconds(next_update_msec), this,
                       &SafeBrowsingProtocolManager::GetNextUpdate);
 }
 
 // According to section 5 of the SafeBrowsing protocol specification, we must
 // back off after a certain number of errors. We only change 'next_update_sec_'
 // when we receive a response from the SafeBrowsing service.
 int SafeBrowsingProtocolManager::GetNextUpdateTime(bool back_off) {
   int next = next_update_sec_;
   if (back_off) {
     next = GetNextBackOffTime(&update_error_count_, &update_back_off_mult_);
@@ skipping 37 matching lines @@
 
 void SafeBrowsingProtocolManager::IssueChunkRequest() {
   // We are only allowed to have one request outstanding at any time.  Also,
   // don't get the next url until the previous one has been written to disk so
   // that we don't use too much memory.
   if (request_.get() || chunk_request_urls_.empty() || chunk_pending_to_write_)
     return;
 
   ChunkUrl next_chunk = chunk_request_urls_.front();
   DCHECK(!next_chunk.url.empty());
-  if (!StartsWithASCII(next_chunk.url, "http://", false) &&
-      !StartsWithASCII(next_chunk.url, "https://", false))
-    next_chunk.url = "http://" + next_chunk.url;
-  GURL chunk_url(next_chunk.url);
+  GURL chunk_url = NextChunkUrl(next_chunk.url);
   request_type_ = CHUNK_REQUEST;
   request_.reset(new URLFetcher(chunk_url, URLFetcher::GET, this));
   request_->set_load_flags(net::LOAD_DISABLE_CACHE);
   request_->set_request_context(request_context_getter_);
   chunk_request_start_ = base::Time::Now();
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::IssueKeyRequest() {
-  GURL key_url(StringPrintf(kSbNewKeyUrl,
-                            client_name_.c_str(),
-                            version_.c_str()));
+  GURL key_url = MacKeyUrl();
   request_type_ = GETKEY_REQUEST;
   request_.reset(new URLFetcher(key_url, URLFetcher::GET, this));
   request_->set_load_flags(net::LOAD_DISABLE_CACHE);
   request_->set_request_context(request_context_getter_);
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::OnGetChunksComplete(
     const std::vector<SBListChunkRanges>& lists, bool database_error) {
-  DCHECK(request_type_ == UPDATE_REQUEST);
+  DCHECK_EQ(request_type_, UPDATE_REQUEST);
   if (database_error) {
     UpdateFinished(false);
     ScheduleNextUpdate(false);
     return;
   }
 
   const bool use_mac = !client_key_.empty();
 
   // Format our stored chunks:
   std::string list_data;
@@ skipping 11 matching lines @@
   // If we have an empty database, let the server know we want data for these
   // lists.
   if (!found_phishing)
     list_data.append(FormatList(
         SBListChunkRanges(safe_browsing_util::kPhishingList), use_mac));
 
   if (!found_malware)
     list_data.append(FormatList(
         SBListChunkRanges(safe_browsing_util::kMalwareList), use_mac));
 
-  std::string url = StringPrintf(kSbUpdateUrl,
-                                 client_name_.c_str(),
-                                 version_.c_str());
-  if (use_mac) {
-    url.append("&wrkey=");
-    url.append(wrapped_key_);
-  }
-
-  GURL update_url(url);
+  GURL update_url = UpdateUrl(use_mac);
   request_.reset(new URLFetcher(update_url, URLFetcher::POST, this));
   request_->set_load_flags(net::LOAD_DISABLE_CACHE);
   request_->set_request_context(request_context_getter_);
   request_->set_upload_data("text/plain", list_data);
   request_->Start();
 
   // Begin the update request timeout.
   update_timer_.Start(TimeDelta::FromSeconds(kSbMaxUpdateWaitSec), this,
                       &SafeBrowsingProtocolManager::UpdateResponseTimeout);
 }
 
 // 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(request_type_ == UPDATE_REQUEST);
+  DCHECK_EQ(request_type_, UPDATE_REQUEST);
   request_.reset();
   UpdateFinished(false);
   ScheduleNextUpdate(false);
 }
 
 void SafeBrowsingProtocolManager::OnChunkInserted() {
   chunk_pending_to_write_ = false;
 
   if (chunk_request_urls_.empty()) {
     UMA_HISTOGRAM_LONG_TIMES("SB2.Update", Time::Now() - last_update_);
     UpdateFinished(true);
   } else {
     IssueChunkRequest();
   }
 }
 
 void SafeBrowsingProtocolManager::ReportMalware(const GURL& malware_url,
                                                 const GURL& page_url,
                                                 const GURL& referrer_url) {
-  std::string report_str = StringPrintf(
-      kSbMalwareReportUrl,
-      EscapeQueryParamValue(malware_url.spec(), true).c_str(),
-      EscapeQueryParamValue(page_url.spec(), true).c_str(),
-      EscapeQueryParamValue(referrer_url.spec(), true).c_str(),
-      client_name_.c_str(),
-      version_.c_str());
-  GURL report_url(report_str);
+  GURL report_url = MalwareReportUrl(malware_url, page_url, referrer_url);
   URLFetcher* report = new URLFetcher(report_url, URLFetcher::GET, this);
   report->set_load_flags(net::LOAD_DISABLE_CACHE);
   report->set_request_context(request_context_getter_);
   report->Start();
   malware_reports_.insert(report);
 }
 
 // static
 std::string SafeBrowsingProtocolManager::FormatList(
     const SBListChunkRanges& list, bool use_mac) {
@@ skipping 26 matching lines @@
 void SafeBrowsingProtocolManager::HandleGetHashError(const Time& now) {
   int next = GetNextBackOffTime(&gethash_error_count_, &gethash_back_off_mult_);
   next_gethash_time_ = now + TimeDelta::FromSeconds(next);
 }
 
 void SafeBrowsingProtocolManager::UpdateFinished(bool success) {
   UMA_HISTOGRAM_COUNTS("SB2.UpdateSize", update_size_);
   update_size_ = 0;
   sb_service_->UpdateFinished(success);
 }
+
+std::string SafeBrowsingProtocolManager::ComposeUrl(
+    const std::string& prefix, const std::string& method,
+    const std::string& client_name, const std::string& version,
+    const std::string& additional_query) {
+  DCHECK(!prefix.empty() && !method.empty() &&
+         !client_name.empty() && !version.empty());
+  std::string url = StringPrintf("%s/%s?client=%s&appver=%s&pver=2.2",
+                                 prefix.c_str(), method.c_str(),
+                                 client_name.c_str(), version.c_str());
+  if (!additional_query.empty()) {
+    url.append(additional_query);
+  }
+  return url;
+}
+
+GURL SafeBrowsingProtocolManager::UpdateUrl(bool use_mac) const {
+  std::string url = ComposeUrl(info_url_prefix_, "downloads", client_name_,
+                               version_, additional_query_);
+  if (use_mac) {
+    url.append("&wrkey=");
+    url.append(wrapped_key_);
+  }
+  return GURL(url);
+}
+
+GURL SafeBrowsingProtocolManager::GetHashUrl(bool use_mac) const {
+  std::string url= ComposeUrl(info_url_prefix_, "gethash", client_name_,
+                              version_, additional_query_);
+  if (use_mac) {
+    url.append("&wrkey=");
+    url.append(wrapped_key_);
+  }
+  return GURL(url);
+}
+
+GURL SafeBrowsingProtocolManager::MacKeyUrl() const {
+  return GURL(ComposeUrl(mackey_url_prefix_, "newkey", client_name_, version_,
+                         additional_query_));
+}
+
+GURL SafeBrowsingProtocolManager::MalwareReportUrl(
+    const GURL& malware_url, const GURL& page_url,
+    const GURL& referrer_url) const {
+  std::string url = ComposeUrl(info_url_prefix_, "report", client_name_,
+                               version_, additional_query_);
+  return GURL(StringPrintf("%s&evts=malblhit&evtd=%s&evtr=%s&evhr=%s",
+      url.c_str(), EscapeQueryParamValue(malware_url.spec(), true).c_str(),
+      EscapeQueryParamValue(page_url.spec(), true).c_str(),
+      EscapeQueryParamValue(referrer_url.spec(), true).c_str()));
+}
+
+GURL SafeBrowsingProtocolManager::NextChunkUrl(const std::string& url) const {
+  std::string next_url;
+  if (!StartsWithASCII(url, "http://", false) &&
+      !StartsWithASCII(url, "https://", false)) {
+    next_url = "http://" + url;
+  } else {
+    next_url = url;
+  }
+  if (!additional_query_.empty())
+    next_url += additional_query_;
+  return GURL(next_url);
+}