Reland: Initialize and reset V4LocalDBManager. Instantiate V4Stores.

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/base64.h"
 #include "base/macros.h"
@@ skipping 82 matching lines @@
 // static
 V4UpdateProtocolManagerFactory* V4UpdateProtocolManager::factory_ = NULL;
 
 // static
 std::unique_ptr<V4UpdateProtocolManager> V4UpdateProtocolManager::Create(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config,
     const base::hash_map<UpdateListIdentifier, std::string>&
         current_list_states,
     V4UpdateCallback callback) {
-  if (!factory_)
+  if (!factory_) {
     factory_ = new V4UpdateProtocolManagerFactoryImpl();
+  }
   return factory_->CreateProtocolManager(request_context_getter, config,
                                          current_list_states, callback);
 }
 
 void V4UpdateProtocolManager::ResetUpdateErrors() {
   update_error_count_ = 0;
   update_back_off_mult_ = 1;
 }
 
 V4UpdateProtocolManager::V4UpdateProtocolManager(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config,
     const base::hash_map<UpdateListIdentifier, std::string>&
         current_list_states,
-    V4UpdateCallback callback)
+    V4UpdateCallback update_callback)
     : current_list_states_(current_list_states),
       update_error_count_(0),
       update_back_off_mult_(1),
       next_update_interval_(base::TimeDelta::FromSeconds(
           base::RandInt(kV4TimerStartIntervalSecMin,
                         kV4TimerStartIntervalSecMax))),
       config_(config),
       request_context_getter_(request_context_getter),
       url_fetcher_id_(0),
-      callback_(callback) {
-  ScheduleNextUpdate(false /* no back off */);
+      update_callback_(update_callback) {
+  // Do not auto-schedule updates. Let the owner (V4LocalDatabaseManager) do it
+  // when it is ready to process updates.
+  DVLOG(1) << "V4UpdateProtocolManager::V4UpdateProtocolManager: "
+           << "next_update_interval_: " << next_update_interval_;
 }
 
 V4UpdateProtocolManager::~V4UpdateProtocolManager() {}
 
 bool V4UpdateProtocolManager::IsUpdateScheduled() const {
   return update_timer_.IsRunning();
 }
 
-void V4UpdateProtocolManager::ScheduleNextUpdate(bool back_off) {
+void V4UpdateProtocolManager::ScheduleNextUpdate() {
+  ScheduleNextUpdateWithBackoff(false);
+}
+
+void V4UpdateProtocolManager::ScheduleNextUpdateWithBackoff(bool back_off) {
+  DCHECK(CalledOnValidThread());
+
   // TODO(vakh): Set disable_auto_update correctly using the command line
   // switch.
   if (config_.disable_auto_update) {
     DCHECK(!IsUpdateScheduled());
     return;
   }
 
   // Reschedule with the new update.
   base::TimeDelta next_update_interval = GetNextUpdateInterval(back_off);
   ScheduleNextUpdateAfterInterval(next_update_interval);
 }
 
 // According to section 5 of the SafeBrowsing protocol specification, we must
 // back off after a certain number of errors.
 base::TimeDelta V4UpdateProtocolManager::GetNextUpdateInterval(bool back_off) {
   DCHECK(CalledOnValidThread());
   DCHECK(next_update_interval_ > base::TimeDelta());
+
   base::TimeDelta next = next_update_interval_;
   if (back_off) {
     next = V4ProtocolManagerUtil::GetNextBackOffInterval(
         &update_error_count_, &update_back_off_mult_);
   }
+
+  if (!last_response_time_.is_null()) {
+    // The callback spent some time updating the database, including disk I/O.
+    // Do not wait that extra time.
+    base::TimeDelta callback_time = Time::Now() - last_response_time_;
+    if (callback_time < next) {
+      next -= callback_time;
+    } else {
+      // If the callback took too long, schedule the next update with no delay.
+      next = base::TimeDelta();
+    }
+  }
   DVLOG(1) << "V4UpdateProtocolManager::GetNextUpdateInterval: "
            << "next_interval: " << next;
   return next;
 }
 
 void V4UpdateProtocolManager::ScheduleNextUpdateAfterInterval(
     base::TimeDelta interval) {
   DCHECK(CalledOnValidThread());
   DCHECK(interval >= base::TimeDelta());
+
   // Unschedule any current timer.
   update_timer_.Stop();
   update_timer_.Start(FROM_HERE, interval, this,
                       &V4UpdateProtocolManager::IssueUpdateRequest);
 }
 
 std::string V4UpdateProtocolManager::GetBase64SerializedUpdateRequestProto(
     const base::hash_map<UpdateListIdentifier, std::string>&
         current_list_states) {
   // Build the request. Client info and client states are not added to the
@@ skipping 64 matching lines @@
 
 void V4UpdateProtocolManager::IssueUpdateRequest() {
   DCHECK(CalledOnValidThread());
 
   // If an update request is already pending, record and return silently.
   if (request_.get()) {
     RecordUpdateResult(V4OperationResult::ALREADY_PENDING_ERROR);
     return;
   }
 
-  std::string req_base64 = GetBase64SerializedUpdateRequestProto(
-      current_list_states_);
+  std::string req_base64 =
+      GetBase64SerializedUpdateRequestProto(current_list_states_);
   GURL update_url = GetUpdateUrl(req_base64);
 
   request_.reset(net::URLFetcher::Create(url_fetcher_id_++, update_url,
                                          net::URLFetcher::GET, this)
                      .release());
 
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_.get());
   request_->Start();
   // TODO(vakh): Handle request timeout.
 }
 
 // net::URLFetcherDelegate implementation ----------------------------------
 
 // SafeBrowsing request responses are handled here.
 void V4UpdateProtocolManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
 
   int response_code = source->GetResponseCode();
   net::URLRequestStatus status = source->GetStatus();
   V4ProtocolManagerUtil::RecordHttpResponseOrErrorCode(
       "SafeBrowsing.V4UpdateHttpResponseOrErrorCode", status, response_code);
 
+  last_response_time_ = Time::Now();
+
   std::vector<ListUpdateResponse> list_update_responses;
-  bool back_off;
   if (status.is_success() && response_code == net::HTTP_OK) {
-    back_off = false;
     RecordUpdateResult(V4OperationResult::STATUS_200);
     ResetUpdateErrors();
     std::string data;
     source->GetResponseAsString(&data);
     if (!ParseUpdateResponse(data, &list_update_responses)) {
       list_update_responses.clear();
       RecordUpdateResult(V4OperationResult::PARSE_ERROR);
     }
+    request_.reset();
+
     // Invoke the callback with list_update_responses.
     // The caller should update its state now, based on list_update_responses.
-    callback_.Run(list_update_responses);
+    // The callback must call ScheduleNextUpdate() at the end to resume
+    // downloading updates.
+    update_callback_.Run(list_update_responses);
   } else {
-    back_off = true;
     DVLOG(1) << "SafeBrowsing GetEncodedUpdates request for: "
              << source->GetURL() << " failed with error: " << status.error()
              << " and response code: " << response_code;
 
     if (status.status() == net::URLRequestStatus::FAILED) {
       RecordUpdateResult(V4OperationResult::NETWORK_ERROR);
     } else {
       RecordUpdateResult(V4OperationResult::HTTP_ERROR);
     }
     // TODO(vakh): Figure out whether it is just a network error vs backoff vs
     // another condition and RecordUpdateResult more accurately.
+
+    request_.reset();
+    ScheduleNextUpdateWithBackoff(true);
   }
-  request_.reset();
-  ScheduleNextUpdate(back_off);
 }
 
 GURL V4UpdateProtocolManager::GetUpdateUrl(
     const std::string& req_base64) const {
   GURL url = V4ProtocolManagerUtil::GetRequestUrl(req_base64, "encodedUpdates",
                                                   config_);
   DVLOG(1) << "V4UpdateProtocolManager::GetUpdateUrl: "
            << "url: " << url;
   return url;
 }
 
 }  // namespace safe_browsing