PVer4: Re-use the PVer3 implementation to get full hashes

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.
 
 // This file should not be build on Android but is currently getting built.
 // TODO(vakh): Fix that: http://crbug.com/621647
 
 #include "components/safe_browsing_db/v4_local_database_manager.h"
 
 #include <vector>
 
 #include "base/callback.h"
+#include "components/safe_browsing_db/v4_get_hash_protocol_manager.h"
+#include "components/safe_browsing_db/v4_protocol_manager_util.h"
+#include "components/safe_browsing_db/v4_update_protocol_manager.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace safe_browsing {
 
 namespace {
 
 // TODO(vakh): Implement this to populate the map appopriately.
 // Filed as http://crbug.com/608075
@@ skipping 117 matching lines @@
     return true;
   }
 
   if (v4_database_) {
     base::hash_set<FullHash> full_hashes;
     V4ProtocolManagerUtil::UrlToFullHashes(url, &full_hashes);
 
     base::hash_set<UpdateListIdentifier> stores_to_look(
         {GetUrlMalwareId(), GetUrlSocEngId()});
     base::hash_set<HashPrefix> matched_hash_prefixes;
-    base::hash_set<UpdateListIdentifier> matched_stores;
+    PlatformTypeSet matched_platforms;
+    ThreatEntryTypeSet matched_threat_entry_types;
+    ThreatTypeSet matched_threat_types;
     MatchedHashPrefixMap matched_hash_prefix_map;
     for (const auto& full_hash : full_hashes) {
       v4_database_->GetStoresMatchingFullHash(full_hash, stores_to_look,
                                               &matched_hash_prefix_map);
       for (const auto& matched_pair : matched_hash_prefix_map) {
-        matched_stores.insert(matched_pair.first);
         matched_hash_prefixes.insert(matched_pair.second);
+        matched_platforms.insert(matched_pair.first.platform_type);
+        matched_threat_entry_types.insert(matched_pair.first.threat_entry_type);
+        matched_threat_types.insert(matched_pair.first.threat_type);
       }
     }
 
-    DCHECK_EQ(matched_stores.empty(), matched_hash_prefixes.empty());
-
-    // TODO(vakh): Return false and fetch full hashes for the matching hash
-    // prefixes.
-    return matched_hash_prefixes.empty();
+    DCHECK_EQ(matched_hash_prefixes.empty(), matched_platforms.empty());
+    DCHECK_EQ(matched_hash_prefixes.empty(),
+              matched_threat_entry_types.empty());
+    DCHECK_EQ(matched_hash_prefixes.empty(), matched_threat_types.empty());

[Scott Hess - ex-Googler, 2016/08/23 20:25:46]

Since they all have to match, I'd pick the shortest one as canonical.  Maybe it
would let you get away without the middle line being wrapped :-).

Alternately, since the next line checks for a specific empty(), the if() and
else could each have appropriate DCHECK() statements for empty() or !empty(). 
That would cost 4 lines, which is your current count.

+    if (matched_hash_prefixes.empty()) {
+      // No matching hash prefixes in the database, URL is good.
+      return true;
+    } else {
+      // Request full hashes.
+      // TODO(vakh): Record the information needed to respond to the client
+      // when the full hash check returns.
+      v4_get_hash_protocol_manager_->GetFullHashes(
+          matched_hash_prefixes, matched_platforms, matched_threat_entry_types,
+          matched_threat_types,
+          base::Bind(&V4LocalDatabaseManager::HandleGetHashes,
+                     base::Unretained(this)));
+      return false;
+    }
   } else {
     // TODO(vakh): Queue the check and process it when the database becomes
     // ready.
     return false;
   }
 }
 
+void V4LocalDatabaseManager::HandleGetHashes(
+    const std::vector<SBFullHashResult>& full_hash_results,
+    const base::Time& negative_cache_expire) {
+  // TODO(vakh): Implement this skeleton.
+  // Ideally this should get a hash_set of FullHash objects. That will be done
+  // after http://crbug.com/616647 is fixed.
+}
+
 void V4LocalDatabaseManager::CancelCheck(Client* client) {
   // TODO(vakh): Implement this skeleton.
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
 }
 
 void V4LocalDatabaseManager::StartOnIOThread(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config) {
   SafeBrowsingDatabaseManager::StartOnIOThread(request_context_getter, config);
 
   db_updated_callback_ = base::Bind(&V4LocalDatabaseManager::DatabaseUpdated,
                                     base::Unretained(this));
 
   SetupUpdateProtocolManager(request_context_getter, config);
 
+  SetupGetHashProtocolManager(request_context_getter, config);
+
   SetupDatabase();
 
   enabled_ = true;
 }
 
 void V4LocalDatabaseManager::SetupUpdateProtocolManager(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config) {
   V4UpdateCallback callback = base::Bind(
       &V4LocalDatabaseManager::UpdateRequestCompleted, base::Unretained(this));
 
   v4_update_protocol_manager_ =
       V4UpdateProtocolManager::Create(request_context_getter, config, callback);
 }
 
+void V4LocalDatabaseManager::SetupGetHashProtocolManager(
+    net::URLRequestContextGetter* request_context_getter,
+    const V4ProtocolConfig& config) {
+  v4_get_hash_protocol_manager_.reset(
+      V4GetHashProtocolManager::Create(request_context_getter, config));
+}
+
 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);
@@ skipping 31 matching lines @@
 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 V4GetHashProtocolManager.
+  // This cancels any in-flight get-hash request.
+  v4_get_hash_protocol_manager_.reset();
+
   // Delete the V4UpdateProtocolManager.
   // This cancels any in-flight update request.
   v4_update_protocol_manager_.reset();
 
   db_updated_callback_.Reset();
 
   SafeBrowsingDatabaseManager::StopOnIOThread(shutdown);
 }
 
 void V4LocalDatabaseManager::UpdateRequestCompleted(
     std::unique_ptr<ParsedServerResponse> parsed_server_response) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   v4_database_->ApplyUpdate(std::move(parsed_server_response),
                             db_updated_callback_);
 }
 
 void V4LocalDatabaseManager::DatabaseUpdated() {
   if (enabled_) {
     v4_update_protocol_manager_->ScheduleNextUpdate(
         v4_database_->GetStoreStateMap());
   }
 }
 
 }  // namespace safe_browsing