Fetch incremental updates. Store new state in V4Store.

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 59 matching lines @@
 
 // The default V4UpdateProtocolManagerFactory.
 class V4UpdateProtocolManagerFactoryImpl
     : public V4UpdateProtocolManagerFactory {
  public:
   V4UpdateProtocolManagerFactoryImpl() {}
   ~V4UpdateProtocolManagerFactoryImpl() override {}
   std::unique_ptr<V4UpdateProtocolManager> CreateProtocolManager(
       net::URLRequestContextGetter* request_context_getter,
       const V4ProtocolConfig& config,
-      const base::hash_map<UpdateListIdentifier, std::string>&
-          current_list_states,
       V4UpdateCallback callback) override {
-    return std::unique_ptr<V4UpdateProtocolManager>(new V4UpdateProtocolManager(
-        request_context_getter, config, current_list_states, callback));
+    return std::unique_ptr<V4UpdateProtocolManager>(
+        new V4UpdateProtocolManager(request_context_getter, config, callback));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(V4UpdateProtocolManagerFactoryImpl);
 };
 
 // V4UpdateProtocolManager implementation --------------------------------
 
 // 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_) {
     factory_ = new V4UpdateProtocolManagerFactoryImpl();
   }
   return factory_->CreateProtocolManager(request_context_getter, config,
-                                         current_list_states, callback);
+                                         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 update_callback)
-    : current_list_states_(current_list_states),
-      update_error_count_(0),
+    : 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),
       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() {
+void V4UpdateProtocolManager::ScheduleNextUpdate(
+    std::unique_ptr<StoreStateMap> store_state_map) {
+  store_state_map_ = std::move(store_state_map);
   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());
@@ skipping 37 matching lines @@
     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);
 }
 
+// static
 std::string V4UpdateProtocolManager::GetBase64SerializedUpdateRequestProto(
-    const base::hash_map<UpdateListIdentifier, std::string>&
-        current_list_states) {
+    const StoreStateMap& store_state_map) {
+  DCHECK(!store_state_map.empty());
   // Build the request. Client info and client states are not added to the
   // request protocol buffer. Client info is passed as params in the url.
   FetchThreatListUpdatesRequest request;
-  for (const auto& entry : current_list_states) {
+  for (const auto& entry : store_state_map) {
     const auto& list_to_update = entry.first;
     const auto& state = entry.second;
     ListUpdateRequest* list_update_request = request.add_list_update_requests();
     list_update_request->set_platform_type(list_to_update.platform_type);
     list_update_request->set_threat_entry_type(
         list_to_update.threat_entry_type);
     list_update_request->set_threat_type(list_to_update.threat_type);
 
     if (!state.empty()) {
       list_update_request->set_state(state);
@@ skipping 52 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_);
+      GetBase64SerializedUpdateRequestProto(*store_state_map_.get());
   GURL update_url;
   net::HttpRequestHeaders headers;
   GetUpdateUrlAndHeaders(req_base64, &update_url, &headers);
 
   std::unique_ptr<net::URLFetcher> fetcher = net::URLFetcher::Create(
       url_fetcher_id_++, update_url, net::URLFetcher::GET, this);
   fetcher->SetExtraRequestHeaders(headers.ToString());
 
   request_.reset(fetcher.release());
 
@@ skipping 22 matching lines @@
     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();
 
+    UMA_HISTOGRAM_COUNTS("SafeBrowsing.V4UpdateResponseSizeKB",
+                         data.size() / 1024);
+
     // Invoke the callback with list_update_responses.
     // The caller should update its state now, based on list_update_responses.
     // The callback must call ScheduleNextUpdate() at the end to resume
     // downloading updates.
     update_callback_.Run(list_update_responses);
   } else {
     DVLOG(1) << "SafeBrowsing GetEncodedUpdates request for: "
              << source->GetURL() << " failed with error: " << status.error()
              << " and response code: " << response_code;
 
@@ skipping 12 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