Makes V4UpdateProtocolManager auto-schedule update fetching

chrome/browser/safe_browsing/local_database_manager.cc

 // Copyright (c) 2012 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 "chrome/browser/safe_browsing/local_database_manager.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/download_protection_service.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/env_vars.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing_db/util.h"
 #include "components/safe_browsing_db/v4_get_hash_protocol_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/url_constants.h"
 
 using content::BrowserThread;
@@ skipping 16 matching lines @@
     result = SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_EMPTY;
   } else if (hit) {
     result = SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_HIT;
   } else {
     result = SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_MISS;
   }
   bool is_download = check_type == BINURL;
   SafeBrowsingProtocolManager::RecordGetHashResult(is_download, result);
 }
 
-bool IsExpectedThreat(
-    const SBThreatType threat_type,
-    const std::vector<SBThreatType>& expected_threats) {
+bool IsExpectedThreat(const SBThreatType threat_type,
+                      const std::vector<SBThreatType>& expected_threats) {
   return expected_threats.end() != std::find(expected_threats.begin(),
                                              expected_threats.end(),
                                              threat_type);
 }
 
 // Returns threat level of the list. Lists with lower threat levels are more
 // severe than lists with higher threat levels. Zero is the severest threat
 // level possible.
 int GetThreatSeverity(ListType threat) {
   switch (threat) {
-    case MALWARE:                  // Falls through.
-    case PHISH:                    // Falls through.
-    case BINURL:                   // Falls through.
-    case CSDWHITELIST:             // Falls through.
-    case DOWNLOADWHITELIST:        // Falls through.
-    case INCLUSIONWHITELIST:       // Falls through.
-    case MODULEWHITELIST:          // Falls through.
-    case EXTENSIONBLACKLIST:       // Falls through.
+    case MALWARE:             // Falls through.
+    case PHISH:               // Falls through.
+    case BINURL:              // Falls through.
+    case CSDWHITELIST:        // Falls through.
+    case DOWNLOADWHITELIST:   // Falls through.
+    case INCLUSIONWHITELIST:  // Falls through.
+    case MODULEWHITELIST:     // Falls through.
+    case EXTENSIONBLACKLIST:  // Falls through.
     case IPBLACKLIST:
       return 0;
     case UNWANTEDURL:
       // UNWANTEDURL is considered less severe than other threats.
       return 1;
     case RESOURCEBLACKLIST:
       // RESOURCEBLACKLIST is even less severe than UNWANTEDURL.
       return 2;
     case INVALID:
       return std::numeric_limits<int>::max();
   }
   NOTREACHED();
   return -1;
 }
 
 // Return the severest list id from the results in |full_hashes| which matches
 // |hash|, or INVALID if none match.
 ListType GetHashSeverestThreatListType(
     const SBFullHash& hash,
     const std::vector<SBFullHashResult>& full_hashes,
     size_t* index) {
   ListType pending_threat = INVALID;
   int pending_threat_severity = GetThreatSeverity(INVALID);
   for (size_t i = 0; i < full_hashes.size(); ++i) {
     if (SBFullHashEqual(hash, full_hashes[i].hash)) {
-      const ListType threat =
-          static_cast<ListType>(full_hashes[i].list_id);
+      const ListType threat = static_cast<ListType>(full_hashes[i].list_id);
       int threat_severity = GetThreatSeverity(threat);
       if (threat_severity < pending_threat_severity) {
         pending_threat = threat;
         pending_threat_severity = threat_severity;
         if (index)
           *index = i;
       }
       if (pending_threat_severity == 0)
         return pending_threat;
     }
@@ skipping 82 matching lines @@
       full_hashes(full_hashes),
       full_hash_results(full_hashes.size(), SB_THREAT_TYPE_SAFE),
       client(client),
       need_get_hash(false),
       check_type(check_type),
       expected_threats(expected_threats) {
   DCHECK_EQ(urls.empty(), !full_hashes.empty())
       << "Exactly one of urls and full_hashes must be set";
 }
 
-LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::~SafeBrowsingCheck() {
-}
+LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::~SafeBrowsingCheck() {}
 
 void LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::
     OnSafeBrowsingResult() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   DCHECK(client);
   DCHECK_EQ(urls.size(), url_results.size());
   DCHECK_EQ(full_hashes.size(), full_hash_results.size());
   if (!urls.empty()) {
     DCHECK(full_hashes.empty());
@@ skipping 16 matching lines @@
                                          url_hit_hash[0]);
         break;
       default:
         NOTREACHED();
     }
   } else if (!full_hashes.empty()) {
     switch (check_type) {
       case EXTENSIONBLACKLIST: {
         std::set<std::string> unsafe_extension_ids;
         for (size_t i = 0; i < full_hashes.size(); ++i) {
-          std::string extension_id =
-              SBFullHashToString(full_hashes[i]);
+          std::string extension_id = SBFullHashToString(full_hashes[i]);
           if (full_hash_results[i] == SB_THREAT_TYPE_EXTENSION)
             unsafe_extension_ids.insert(extension_id);
         }
         client->OnCheckExtensionsResult(unsafe_extension_ids);
         break;
       }
       default:
         NOTREACHED();
     }
   } else {
@@ skipping 66 matching lines @@
   return false;
 }
 
 bool LocalSafeBrowsingDatabaseManager::CanCheckResourceType(
     content::ResourceType resource_type) const {
   // We check all types since most checks are fast.
   return true;
 }
 
 bool LocalSafeBrowsingDatabaseManager::CanCheckUrl(const GURL& url) const {
-  return url.SchemeIs(url::kFtpScheme) ||
-         url.SchemeIs(url::kHttpScheme) ||
+  return url.SchemeIs(url::kFtpScheme) || url.SchemeIs(url::kHttpScheme) ||
          url.SchemeIs(url::kHttpsScheme);
 }
 
 bool LocalSafeBrowsingDatabaseManager::CheckDownloadUrl(
     const std::vector<GURL>& url_chain,
     Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !enable_download_protection_)
     return true;
 
   // We need to check the database for url prefix, and later may fetch the url
   // from the safebrowsing backends. These need to be asynchronous.
-  SafeBrowsingCheck* check =
-      new SafeBrowsingCheck(url_chain,
-                            std::vector<SBFullHash>(),
-                            client,
-                            BINURL,
-                            std::vector<SBThreatType>(1,
-                                SB_THREAT_TYPE_BINARY_MALWARE_URL));
+  SafeBrowsingCheck* check = new SafeBrowsingCheck(
+      url_chain, std::vector<SBFullHash>(), client, BINURL,
+      std::vector<SBThreatType>(1, SB_THREAT_TYPE_BINARY_MALWARE_URL));
   std::vector<SBPrefix> prefixes;
   SafeBrowsingDatabase::GetDownloadUrlPrefixes(url_chain, &prefixes);
   StartSafeBrowsingCheck(
       check,
       base::Bind(&LocalSafeBrowsingDatabaseManager::CheckDownloadUrlOnSBThread,
                  this, prefixes));
   return false;
 }
 
 bool LocalSafeBrowsingDatabaseManager::CheckExtensionIDs(
-    const std::set<std::string>& extension_ids, Client* client) {
+    const std::set<std::string>& extension_ids,
+    Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_ || !enable_extension_blacklist_)
     return true;
 
   std::vector<SBFullHash> extension_id_hashes;
   std::transform(extension_ids.begin(), extension_ids.end(),
-                 std::back_inserter(extension_id_hashes),
-                 StringToSBFullHash);
+                 std::back_inserter(extension_id_hashes), StringToSBFullHash);
   std::vector<SBPrefix> prefixes;
   for (const SBFullHash& hash : extension_id_hashes)
     prefixes.push_back(hash.prefix);
 
   SafeBrowsingCheck* check = new SafeBrowsingCheck(
-      std::vector<GURL>(),
-      extension_id_hashes,
-      client,
-      EXTENSIONBLACKLIST,
+      std::vector<GURL>(), extension_id_hashes, client, EXTENSIONBLACKLIST,
       std::vector<SBThreatType>(1, SB_THREAT_TYPE_EXTENSION));
   StartSafeBrowsingCheck(
       check,
       base::Bind(&LocalSafeBrowsingDatabaseManager::CheckExtensionIDsOnSBThread,
                  this, prefixes));
   return false;
 }
 
-bool LocalSafeBrowsingDatabaseManager::CheckResourceUrl(
-    const GURL& url, Client* client) {
+bool LocalSafeBrowsingDatabaseManager::CheckResourceUrl(const GURL& url,
+                                                        Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_ || !CanCheckUrl(url))
     return true;
 
-  std::vector<SBThreatType> expected_threats =
-      {SB_THREAT_TYPE_BLACKLISTED_RESOURCE};
+  std::vector<SBThreatType> expected_threats = {
+      SB_THREAT_TYPE_BLACKLISTED_RESOURCE};
 
   if (!MakeDatabaseAvailable()) {
-    QueuedCheck queued_check(RESOURCEBLACKLIST, client, url,
-                             expected_threats, base::TimeTicks::Now());
+    QueuedCheck queued_check(RESOURCEBLACKLIST, client, url, expected_threats,
+                             base::TimeTicks::Now());
     queued_checks_.push_back(queued_check);
     return false;
   }
 
   SafeBrowsingCheck* check =
       new SafeBrowsingCheck({url}, std::vector<SBFullHash>(), client,
                             RESOURCEBLACKLIST, expected_threats);
 
   std::vector<SBPrefix> prefixes;
   SafeBrowsingDatabase::GetDownloadUrlPrefixes(check->urls, &prefixes);
@@ skipping 70 matching lines @@
 
 bool LocalSafeBrowsingDatabaseManager::IsCsdWhitelistKillSwitchOn() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !MakeDatabaseAvailable()) {
     return true;
   }
   return database_->IsCsdWhitelistKillSwitchOn();
 }
 
 bool LocalSafeBrowsingDatabaseManager::CheckBrowseUrl(const GURL& url,
-                                                 Client* client) {
+                                                      Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_)
     return true;
 
   if (!CanCheckUrl(url))
     return true;
 
   std::vector<SBThreatType> expected_threats;
   expected_threats.push_back(SB_THREAT_TYPE_URL_MALWARE);
   expected_threats.push_back(SB_THREAT_TYPE_URL_PHISHING);
   expected_threats.push_back(SB_THREAT_TYPE_URL_UNWANTED);
 
   const base::TimeTicks start = base::TimeTicks::Now();
   if (!MakeDatabaseAvailable()) {
     QueuedCheck queued_check(MALWARE,  // or PHISH
-                             client,
-                             url,
-                             expected_threats,
-                             start);
+                             client, url, expected_threats, start);
     queued_checks_.push_back(queued_check);
     return false;
   }
 
   // Cache hits should, in general, be the same for both (ignoring potential
   // cache evictions in the second call for entries that were just about to be
   // evicted in the first call).
   // TODO(gab): Refactor SafeBrowsingDatabase to avoid depending on this here.
   std::vector<SBFullHashResult> cache_hits;
 
   std::vector<SBFullHash> full_hashes;
   UrlToFullHashes(url, false, &full_hashes);
 
   std::vector<SBPrefix> browse_prefix_hits;
   bool browse_prefix_match = database_->ContainsBrowseHashes(
       full_hashes, &browse_prefix_hits, &cache_hits);
 
   std::vector<SBPrefix> unwanted_prefix_hits;
   std::vector<SBFullHashResult> unused_cache_hits;
   bool unwanted_prefix_match = database_->ContainsUnwantedSoftwareHashes(
       full_hashes, &unwanted_prefix_hits, &unused_cache_hits);
 
   // Merge the two pre-sorted prefix hits lists.
   // TODO(gab): Refactor SafeBrowsingDatabase for it to return this merged list
   // by default rather than building it here.
   std::vector<SBPrefix> prefix_hits(browse_prefix_hits.size() +
                                     unwanted_prefix_hits.size());
-  std::merge(browse_prefix_hits.begin(),
-             browse_prefix_hits.end(),
-             unwanted_prefix_hits.begin(),
-             unwanted_prefix_hits.end(),
+  std::merge(browse_prefix_hits.begin(), browse_prefix_hits.end(),
+             unwanted_prefix_hits.begin(), unwanted_prefix_hits.end(),
              prefix_hits.begin());
   prefix_hits.erase(std::unique(prefix_hits.begin(), prefix_hits.end()),
                     prefix_hits.end());
 
   UMA_HISTOGRAM_TIMES("SB2.FilterCheck", base::TimeTicks::Now() - start);
 
   if (!browse_prefix_match && !unwanted_prefix_match)
     return true;  // URL is okay.
 
   // Needs to be asynchronous, since we could be in the constructor of a
   // ResourceDispatcherHost event handler which can't pause there.
   // This check will ping the Safe Browsing servers and get all lists which it
   // matches. These lists will then be filtered against the |expected_threats|
   // and the result callback for MALWARE (which is the same as for PHISH and
   // UNWANTEDURL) will eventually be invoked with the final decision.
-  SafeBrowsingCheck* check = new SafeBrowsingCheck(std::vector<GURL>(1, url),
-                                                   std::vector<SBFullHash>(),
-                                                   client,
-                                                   MALWARE,
-                                                   expected_threats);
+  SafeBrowsingCheck* check = new SafeBrowsingCheck(
+      std::vector<GURL>(1, url), std::vector<SBFullHash>(), client, MALWARE,
+      expected_threats);
   check->need_get_hash = cache_hits.empty();
   check->prefix_hits.swap(prefix_hits);
   check->cache_hits.swap(cache_hits);
   checks_.insert(check);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&LocalSafeBrowsingDatabaseManager::OnCheckDone, this, check));
 
   return false;
 }
 
 void LocalSafeBrowsingDatabaseManager::CancelCheck(Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (CurrentChecks::iterator i = checks_.begin(); i != checks_.end(); ++i) {
     // We can't delete matching checks here because the db thread has a copy of
     // the pointer.  Instead, we simply NULL out the client, and when the db
     // thread calls us back, we'll clean up the check.
     if ((*i)->client == client)
       (*i)->client = NULL;
   }
 
   // Scan the queued clients store. Clients may be here if they requested a URL
   // check before the database has finished loading.
   for (std::deque<QueuedCheck>::iterator it(queued_checks_.begin());
-       it != queued_checks_.end(); ) {
+       it != queued_checks_.end();) {
     // In this case it's safe to delete matches entirely since nothing has a
     // pointer to them.
     if (it->client == client)
       it = queued_checks_.erase(it);
     else
       ++it;
   }
 }
 
 void LocalSafeBrowsingDatabaseManager::HandleGetHashResults(
@@ skipping 39 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   DCHECK(!callback.is_null());
   safe_browsing_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalSafeBrowsingDatabaseManager::AddDatabaseChunks, this,
                  list, base::Passed(&chunks), callback));
 }
 
 void LocalSafeBrowsingDatabaseManager::DeleteChunks(
-    scoped_ptr<std::vector<SBChunkDelete> > chunk_deletes) {
+    scoped_ptr<std::vector<SBChunkDelete>> chunk_deletes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   safe_browsing_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalSafeBrowsingDatabaseManager::DeleteDatabaseChunks, this,
                  base::Passed(&chunk_deletes)));
 }
 
 void LocalSafeBrowsingDatabaseManager::UpdateStarted() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 15 matching lines @@
 }
 
 void LocalSafeBrowsingDatabaseManager::ResetDatabase() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   safe_browsing_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalSafeBrowsingDatabaseManager::OnResetDatabase, this));
 }
 
+bool LocalSafeBrowsingDatabaseManager::IsRunningHeadless() {
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  return env->HasVar(env_vars::kHeadless);
+}
+
+void LocalSafeBrowsingDatabaseManager::UpdateRequestCompleted(
+    const std::vector<ListUpdateResponse>& responses) {
+  // TODO(vakh): Updates downloaded. Store them on disk and record new state.
+}
+
 void LocalSafeBrowsingDatabaseManager::StartOnIOThread(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SafeBrowsingDatabaseManager::StartOnIOThread(request_context_getter, config);
 
+  V4UpdateCallback callback =
+      base::Bind(&LocalSafeBrowsingDatabaseManager::UpdateRequestCompleted,
+                 base::Unretained(this));
+  v4_update_protocol_manager_ = V4UpdateProtocolManager::Create(
+      request_context_getter, config, current_list_states_, callback,
+      IsRunningHeadless());
+
   if (enabled_)
     return;
 
   // 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 (!safe_browsing_task_runner_) {
     base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
     safe_browsing_task_runner_ =
         pool->GetSequencedTaskRunnerWithShutdownBehavior(
             pool->GetSequenceToken(),
@@ skipping 27 matching lines @@
 LocalSafeBrowsingDatabaseManager::QueuedCheck::QueuedCheck(
     const ListType check_type,
     Client* client,
     const GURL& url,
     const std::vector<SBThreatType>& expected_threats,
     const base::TimeTicks& start)
     : check_type(check_type),
       client(client),
       url(url),
       expected_threats(expected_threats),
-      start(start) {
-}
+      start(start) {}
 
 LocalSafeBrowsingDatabaseManager::QueuedCheck::QueuedCheck(
     const QueuedCheck& other) = default;
 
-LocalSafeBrowsingDatabaseManager::QueuedCheck::~QueuedCheck() {
-}
+LocalSafeBrowsingDatabaseManager::QueuedCheck::~QueuedCheck() {}
 
 void LocalSafeBrowsingDatabaseManager::DoStopOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_)
     return;
 
   enabled_ = false;
 
   // Delete queued checks, calling back any clients with 'SB_THREAT_TYPE_SAFE'.
   while (!queued_checks_.empty()) {
     QueuedCheck queued = queued_checks_.front();
     if (queued.client) {
       SafeBrowsingCheck sb_check(std::vector<GURL>(1, queued.url),
-                                 std::vector<SBFullHash>(),
-                                 queued.client,
-                                 queued.check_type,
-                                 queued.expected_threats);
+                                 std::vector<SBFullHash>(), queued.client,
+                                 queued.check_type, queued.expected_threats);
       sb_check.OnSafeBrowsingResult();
     }
     queued_checks_.pop_front();
   }
 
   // Close the database.  Cases to avoid:
   //  * If |closing_database_| is true, continuing will queue up a second
   //    request, |closing_database_| will be reset after handling the first
   //    request, and if any functions on the db thread recreate the database, we
   //    could start using it on the IO thread and then have the second request
   //    handler delete it out from under us.
   //  * If |database_| is NULL, then either no creation request is in flight, in
   //    which case we don't need to do anything, or one is in flight, in which
   //    case the database will be recreated before our deletion request is
   //    handled, and could be used on the IO thread in that time period, leading
   //    to the same problem as above.
   // Checking DatabaseAvailable() avoids both of these.
   if (DatabaseAvailable()) {
     closing_database_ = true;
     safe_browsing_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&LocalSafeBrowsingDatabaseManager::OnCloseDatabase, this));
   }
 
   // Delete pending checks, calling back any clients with 'SB_THREAT_TYPE_SAFE'.
   // We have to do this after the db thread returns because methods on it can
   // have copies of these pointers, so deleting them might lead to accessing
   // garbage.
-  for (CurrentChecks::iterator it = checks_.begin();
-       it != checks_.end(); ++it) {
+  for (CurrentChecks::iterator it = checks_.begin(); it != checks_.end();
+       ++it) {
     SafeBrowsingCheck* check = *it;
     if (check->client)
       check->OnSafeBrowsingResult();
   }
   STLDeleteElements(&checks_);
 
   gethash_requests_.clear();
 }
 
 bool LocalSafeBrowsingDatabaseManager::DatabaseAvailable() const {
@@ skipping 201 matching lines @@
   while (!queued_checks_.empty()) {
     QueuedCheck check = queued_checks_.front();
     DCHECK(!check.start.is_null());
     LOCAL_HISTOGRAM_TIMES("SB.QueueDelay",
                           base::TimeTicks::Now() - check.start);
     // If CheckUrl() determines the URL is safe immediately, it doesn't call the
     // client's handler function (because normally it's being directly called by
     // the client).  Since we're not the client, we have to convey this result.
     if (check.client && CheckBrowseUrl(check.url, check.client)) {
       SafeBrowsingCheck sb_check(std::vector<GURL>(1, check.url),
-                                 std::vector<SBFullHash>(),
-                                 check.client,
-                                 check.check_type,
-                                 check.expected_threats);
+                                 std::vector<SBFullHash>(), check.client,
+                                 check.check_type, check.expected_threats);
       sb_check.OnSafeBrowsingResult();
     }
     queued_checks_.pop_front();
   }
 }
 
 void LocalSafeBrowsingDatabaseManager::AddDatabaseChunks(
     const std::string& list_name,
     scoped_ptr<std::vector<scoped_ptr<SBChunkData>>> chunks,
     AddChunksCallback callback) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   if (chunks)
     GetDatabase()->InsertChunks(list_name, *chunks);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&LocalSafeBrowsingDatabaseManager::OnAddChunksComplete, this,
                  callback));
 }
 
 void LocalSafeBrowsingDatabaseManager::DeleteDatabaseChunks(
-    scoped_ptr<std::vector<SBChunkDelete> > chunk_deletes) {
+    scoped_ptr<std::vector<SBChunkDelete>> chunk_deletes) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   if (chunk_deletes)
     GetDatabase()->DeleteChunks(*chunk_deletes);
 }
 
 void LocalSafeBrowsingDatabaseManager::DatabaseUpdateFinished(
     bool update_succeeded) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   GetDatabase()->UpdateFinished(update_succeeded);
   DCHECK(database_update_in_progress_);
@@ skipping 83 matching lines @@
     }
   }
 
   if (expected_full_hashes.empty()) {
     SafeBrowsingCheckDone(check);
     return false;
   }
 
   for (size_t i = 0; i < check->urls.size(); ++i) {
     size_t threat_index;
-    SBThreatType threat = GetUrlSeverestThreatType(check->urls[i],
-                                                   expected_full_hashes,
-                                                   &threat_index);
+    SBThreatType threat = GetUrlSeverestThreatType(
+        check->urls[i], expected_full_hashes, &threat_index);
     if (threat != SB_THREAT_TYPE_SAFE) {
       check->url_results[i] = threat;
       check->url_metadata[i] = expected_full_hashes[threat_index].metadata;
       const SBFullHash& hash = expected_full_hashes[threat_index].hash;
-      check->url_hit_hash[i] = std::string(hash.full_hash,
-                                           arraysize(hash.full_hash));
+      check->url_hit_hash[i] =
+          std::string(hash.full_hash, arraysize(hash.full_hash));
       is_threat = true;
     }
   }
 
   for (size_t i = 0; i < check->full_hashes.size(); ++i) {
     SBThreatType threat =
         GetHashSeverestThreatType(check->full_hashes[i], expected_full_hashes);
     if (threat != SB_THREAT_TYPE_SAFE) {
       check->full_hash_results[i] = threat;
       is_threat = true;
@@ skipping 103 matching lines @@
       FROM_HERE, base::Bind(&LocalSafeBrowsingDatabaseManager::TimeoutCallback,
                             check->weak_ptr_factory_->GetWeakPtr(), check),
       check_timeout_);
 }
 
 bool LocalSafeBrowsingDatabaseManager::download_protection_enabled() const {
   return enable_download_protection_;
 }
 
 }  // namespace safe_browsing