Handle timeout for update requests.

components/safe_browsing_db/v4_update_protocol_manager.cc

 // Copyright 2016 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 "components/safe_browsing_db/v4_update_protocol_manager.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/macros.h"
@@ skipping 52 matching lines @@
 }  // namespace
 
 namespace safe_browsing {
 
 // Minimum time, in seconds, from start up before we must issue an update query.
 static const int kV4TimerStartIntervalSecMin = 60;
 
 // Maximum time, in seconds, from start up before we must issue an update query.
 static const int kV4TimerStartIntervalSecMax = 300;
 
+// Maximum time, in seconds, to wait for a response to an update request.
+static const int kV4TimerUpdateWaitSecMax = 30;
+
 // The default V4UpdateProtocolManagerFactory.
 class V4UpdateProtocolManagerFactoryImpl
     : public V4UpdateProtocolManagerFactory {
  public:
   V4UpdateProtocolManagerFactoryImpl() {}
   ~V4UpdateProtocolManagerFactoryImpl() override {}
   std::unique_ptr<V4UpdateProtocolManager> CreateProtocolManager(
       net::URLRequestContextGetter* request_context_getter,
       const V4ProtocolConfig& config,
       V4UpdateCallback callback) override {
@@ skipping 158 matching lines @@
         response.minimum_wait_duration().seconds();
 
     // Do not let the next_update_interval_ to be too low.
     if (minimum_wait_duration_seconds < kV4TimerStartIntervalSecMin) {
       minimum_wait_duration_seconds = kV4TimerStartIntervalSecMin;
     }
     next_update_interval_ =
         base::TimeDelta::FromSeconds(minimum_wait_duration_seconds);
   }
 
-  // TODO(vakh): Do something useful with this response.
   for (ListUpdateResponse& list_update_response :
        *response.mutable_list_update_responses()) {
     if (!list_update_response.has_platform_type()) {
       RecordParseUpdateResult(NO_PLATFORM_TYPE_ERROR);
     } else if (!list_update_response.has_threat_entry_type()) {
       RecordParseUpdateResult(NO_THREAT_ENTRY_TYPE_ERROR);
     } else if (!list_update_response.has_threat_type()) {
       RecordParseUpdateResult(NO_THREAT_TYPE_ERROR);
     } else if (!list_update_response.has_new_client_state()) {
       RecordParseUpdateResult(NO_STATE_ERROR);
@@ skipping 24 matching lines @@
       url_fetcher_id_++, update_url, net::URLFetcher::GET, this);
   fetcher->SetExtraRequestHeaders(headers.ToString());
   data_use_measurement::DataUseUserData::AttachToFetcher(
       fetcher.get(), data_use_measurement::DataUseUserData::SAFE_BROWSING);
 
   request_.reset(fetcher.release());
 
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_.get());
   request_->Start();
-  // TODO(vakh): Handle request timeout.
+
+  // Begin the update request timeout.
+  timeout_timer_.Start(FROM_HERE,
+                       TimeDelta::FromSeconds(kV4TimerUpdateWaitSecMax), this,
+                       &V4UpdateProtocolManager::HandleTimeout);
+}
+
+void V4UpdateProtocolManager::HandleTimeout() {
+  UMA_HISTOGRAM_COUNTS_100("SafeBrowsing.V4Update.Timeout.Count", 1);

[Nathan Parker, 2016/11/08 23:39:29]

Or UMA_HISTOGRAM_BOOLEAN("..", true)
either way

[vakh (use Gerrit instead), 2016/11/09 00:08:51]

Done.

+  request_.reset();
+  ScheduleNextUpdateWithBackoff(false);
 }
 
 // net::URLFetcherDelegate implementation ----------------------------------
 
 // SafeBrowsing request responses are handled here.
 void V4UpdateProtocolManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
 
+  timeout_timer_.Stop();
+
   int response_code = source->GetResponseCode();
   net::URLRequestStatus status = source->GetStatus();
   V4ProtocolManagerUtil::RecordHttpResponseOrErrorCode(
       "SafeBrowsing.V4Update.Network.Result", status, response_code);
 
   last_response_time_ = Time::Now();
 
   std::unique_ptr<ParsedServerResponse> parsed_server_response(
       new ParsedServerResponse);
   if (status.is_success() && response_code == net::HTTP_OK) {
@@ skipping 34 matching lines @@
 
 void V4UpdateProtocolManager::GetUpdateUrlAndHeaders(
     const std::string& req_base64,
     GURL* gurl,
     net::HttpRequestHeaders* headers) const {
   V4ProtocolManagerUtil::GetRequestUrlAndHeaders(
       req_base64, "threatListUpdates:fetch", config_, gurl, headers);
 }
 
 }  // namespace safe_browsing