Fetch incremental updates. Store new state in V4Store.

components/safe_browsing_db/v4_local_database_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_local_database_manager.h"
 
 #include <vector>
 
 #include "base/callback.h"
 #include "components/safe_browsing_db/safebrowsing.pb.h"
@@ skipping 134 matching lines @@
   SetupUpdateProtocolManager(request_context_getter, config);
 
   SetupDatabase();
 
   enabled_ = true;
 }
 
 void V4LocalDatabaseManager::SetupUpdateProtocolManager(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config) {
-#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX)
-  // TODO(vakh): Remove this if/endif block when the V4Database is implemented.
-  // Filed as http://crbug.com/608075
-  UpdateListIdentifier update_list_identifier;
-#if defined(OS_WIN)
-  update_list_identifier.platform_type = WINDOWS_PLATFORM;
-#elif defined(OS_LINUX)
-  update_list_identifier.platform_type = LINUX_PLATFORM;
-#else
-  update_list_identifier.platform_type = OSX_PLATFORM;
-#endif
-  update_list_identifier.threat_entry_type = URL;
-  update_list_identifier.threat_type = MALWARE_THREAT;
-  current_list_states_[update_list_identifier] = "";
-#endif
-
   V4UpdateCallback callback = base::Bind(
       &V4LocalDatabaseManager::UpdateRequestCompleted, base::Unretained(this));
 
-  v4_update_protocol_manager_ = V4UpdateProtocolManager::Create(
-      request_context_getter, config, current_list_states_, callback);
+  v4_update_protocol_manager_ =
+      V4UpdateProtocolManager::Create(request_context_getter, config, callback);
 }
 
 void V4LocalDatabaseManager::SetupDatabase() {
   DCHECK(!base_path_.empty());
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Only get a new task runner if there isn't one already. If the service has
   // previously been started and stopped, a task runner could already exist.
   if (!task_runner_) {
     base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
     task_runner_ = pool->GetSequencedTaskRunnerWithShutdownBehavior(
         pool->GetSequenceToken(), base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   }
 
-  // TODO(vakh): list_info_map should probably be a hard-coded map.
-  ListInfoMap list_info_map;
+  StoreFileNameMap store_file_name_map;
+  PopulateStoreFileNameMap(&store_file_name_map);
 
   // Do not create the database on the IO thread since this may be an expensive
   // operation. Instead, do that on the task_runner and when the new database
   // has been created, swap it out on the IO thread.
+  DCHECK(!store_file_name_map.empty());
+  DatabaseUpdatedCallback db_updated_callback = base::Bind(
+      &V4LocalDatabaseManager::DatabaseUpdated, base::Unretained(this));
   NewDatabaseReadyCallback db_ready_callback = base::Bind(
       &V4LocalDatabaseManager::DatabaseReady, base::Unretained(this));
-  V4Database::Create(task_runner_, base_path_, list_info_map,
-                     db_ready_callback);
+  V4Database::Create(task_runner_, base_path_, store_file_name_map,
+                     db_updated_callback, db_ready_callback);
+}
+
+void V4LocalDatabaseManager::PopulateStoreFileNameMap(
+    StoreFileNameMap* store_file_name_map) {
+#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX)
+  // TODO(vakh): Implement this to populate the map appopriately.
+  // Filed as http://crbug.com/608075
+  PlatformType platform_type;
+#if defined(OS_WIN)
+  platform_type = WINDOWS_PLATFORM;
+#elif defined(OS_LINUX)
+  platform_type = LINUX_PLATFORM;
+#else

[Nathan Parker, 2016/06/15 21:24:18]

An idea: How about requiring a known OS?  You could check if MAC_OS, and then
the #else use an #error (i.e. fail to compile).  That way we don't get
surprises.  And we should figure out what to do with chromeos.  (==linux?)

[vakh (use Gerrit instead), 2016/06/16 01:07:35]

Done.

+  platform_type = OSX_PLATFORM;
+#endif
+  UpdateListIdentifier update_list_identifier(platform_type, URL,
+                                              MALWARE_THREAT);
+  (*store_file_name_map)[update_list_identifier] = "os_url_malware.store";

[Nathan Parker, 2016/06/15 21:24:19]

We should come up with a list of all the filenames we plan to use (for existing
lists), to make sure we've got a naming strategy that'll work going forward. 
And document that.

I think we should put them in a "Safe Browsing/" directory, and given that most
things in the data dir use Upper Case and Spaces, we should stick to that too.

(Could be done later)  This could be defined at compile time rather than run
time, to make it easier to read and edit.  

StoreFilenameMap default_store_filename_map = {
  {{PLATFORM, URL, MALWARE_THREAT},            "some malware filename"},
  {{PLATFORM, URL, SOCIAL_ENGINEERING_PUBLIC}, "yadda yadda"},
...
}

With that, PLATFORM could be a #define'd macro.

[vakh (use Gerrit instead), 2016/06/16 01:07:35]

Acknowledged. Work for a later CL.

[Nathan Parker, 2016/06/17 21:34:19]

When we we change the names later, we'll need to write code to delete these
since they'll be left on some users' disk.

[vakh (use Gerrit instead), 2016/06/23 00:28:06]

Done.

The files are being created under the "Safe Browsing/" directory, which we get
from safe_browsing_service.
Inside that directory, I don't know of any good reason to have spaces in names,
but I agree that Chromium doesn't use underscores so I've changed the files to
have CamelCase. See patch 17.

+
+  update_list_identifier.threat_type = SOCIAL_ENGINEERING_PUBLIC;
+  (*store_file_name_map)[update_list_identifier] = "os_url_soceng.store";
+#endif
 }
 
 void V4LocalDatabaseManager::DatabaseReady(
     std::unique_ptr<V4Database> v4_database) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // The following check is needed because it is possible that by the time the
   // database is ready, StopOnIOThread has been called.
   if (enabled_) {
     v4_database_ = std::move(v4_database);
 
     // The database is in place. Start fetching updates now.
-    v4_update_protocol_manager_->ScheduleNextUpdate();
+    v4_update_protocol_manager_->ScheduleNextUpdate(
+        v4_database_->store_state_map());
   } else {
     // Schedule the deletion of v4_database off IO thread.
     V4Database::Destroy(std::move(v4_database));
   }
 }
 
 void V4LocalDatabaseManager::StopOnIOThread(bool shutdown) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   enabled_ = false;
 
   // Delete the V4Database. Any pending writes to disk are completed.
   // This operation happens on the task_runner on which v4_database_ operates
   // and doesn't block the IO thread.
   V4Database::Destroy(std::move(v4_database_));
 
   // Delete the V4UpdateProtocolManager.
   // This cancels any in-flight update request.
   v4_update_protocol_manager_.reset();
 
   SafeBrowsingDatabaseManager::StopOnIOThread(shutdown);
 }
 
 void V4LocalDatabaseManager::UpdateRequestCompleted(
     const std::vector<ListUpdateResponse>& responses) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  v4_database_->ApplyUpdate(responses);
+}
 
-  // TODO(vakh): Updates downloaded. Store them on disk and record new state.
-  v4_update_protocol_manager_->ScheduleNextUpdate();
+void V4LocalDatabaseManager::DatabaseUpdated() {
+  v4_update_protocol_manager_->ScheduleNextUpdate(
+      v4_database_->store_state_map());
 }
 
 }  // namespace safe_browsing