Add "light speed" experiment code for SafeBrowsing service.

chrome/browser/safe_browsing/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/database_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/safe_browsing/malware_details.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 "components/metrics/metrics_service.h"
 #include "components/startup_metric_utils/startup_metric_utils.h"
+#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "url/url_constants.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Timeout for match checks, e.g. download URLs, hashes.
 const int kCheckTimeoutMs = 10000;
@@ skipping 117 matching lines @@
     case safe_browsing_util::BINURL:
       return SB_THREAT_TYPE_BINARY_MALWARE_URL;
     case safe_browsing_util::EXTENSIONBLACKLIST:
       return SB_THREAT_TYPE_EXTENSION;
     default:
       DVLOG(1) << "Unknown safe browsing list id " << list_type;
       return SB_THREAT_TYPE_SAFE;
   }
 }
 
+// TODO(asvitkine): Experimental code for measuring start up impact of SB.
+// Remove when experimentation is complete. http://crbug.com/450037
+bool ShouldDisableSafeBrowsing() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  static bool disable_sb =
+      !variations::GetVariationParamValue("LightSpeed", "DisableSB").empty();

[gab, 2015/02/13 22:58:21]

Hmmm actually, isn't this boolean logic backwards? i.e. either this bool should
be named |enable_sb| or their shouldn't be a '!'?

I think you want to drop the '!' and keep the rest.

[gab, 2015/02/13 23:00:09]

Oh nvm, it's !empty(), i.e. disabled == not not disabled...! Or enabled = not
not not disabled :-)!

Ugh..!

[gab, 2015/02/13 23:01:36]

Would be nice to have a boolean method on that API rather than have to check
!empty(), just saying :-)!

+  return disable_sb;
+}
+
 }  // namespace
 
 // static
 SBThreatType SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
     const SBFullHash& hash,
     const std::vector<SBFullHashResult>& full_hashes) {
   return GetThreatTypeFromListType(
       GetHashSeverestThreatListType(hash, full_hashes, NULL));
 }
 
@@ skipping 406 matching lines @@
   std::vector<SBPrefix> prefixes = check->prefix_hits;
   OnHandleGetHashResults(check, full_hashes);  // 'check' is deleted here.
 
   // Cache the GetHash results.
   if (cache_lifetime != base::TimeDelta() && MakeDatabaseAvailable())
     database_->CacheHashResults(prefixes, full_hashes, cache_lifetime);
 }
 
 void SafeBrowsingDatabaseManager::GetChunks(GetChunksCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (ShouldDisableSafeBrowsing())
+    return;
+
   DCHECK(enabled_);
   DCHECK(!callback.is_null());
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
       &SafeBrowsingDatabaseManager::GetAllChunksFromDatabase, this, callback));
 }
 
 void SafeBrowsingDatabaseManager::AddChunks(
     const std::string& list,
     scoped_ptr<ScopedVector<SBChunkData> > chunks,
     AddChunksCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (ShouldDisableSafeBrowsing())
+    return;
+
   DCHECK(enabled_);
   DCHECK(!callback.is_null());
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
       &SafeBrowsingDatabaseManager::AddDatabaseChunks, this, list,
       base::Passed(&chunks), callback));
 }
 
 void SafeBrowsingDatabaseManager::DeleteChunks(
     scoped_ptr<std::vector<SBChunkDelete> > chunk_deletes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (ShouldDisableSafeBrowsing())
+    return;
+
   DCHECK(enabled_);
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
       &SafeBrowsingDatabaseManager::DeleteDatabaseChunks, this,
       base::Passed(&chunk_deletes)));
 }
 
 void SafeBrowsingDatabaseManager::UpdateStarted() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (ShouldDisableSafeBrowsing())
+    return;
+
   DCHECK(enabled_);
   DCHECK(!update_in_progress_);
   update_in_progress_ = true;
 }
 
 void SafeBrowsingDatabaseManager::UpdateFinished(bool update_succeeded) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   if (update_in_progress_) {
     update_in_progress_ = false;
     safe_browsing_thread_->message_loop()->PostTask(FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManager::DatabaseUpdateFinished,
                  this, update_succeeded));
   }
 }
 
 void SafeBrowsingDatabaseManager::ResetDatabase() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
       &SafeBrowsingDatabaseManager::OnResetDatabase, this));
 }
 
 void SafeBrowsingDatabaseManager::StartOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (enabled_)
     return;
 
+  if (ShouldDisableSafeBrowsing())
+    return;
+
   DCHECK(!safe_browsing_thread_.get());
   safe_browsing_thread_.reset(new base::Thread("Chrome_SafeBrowsingThread"));
   if (!safe_browsing_thread_->Start())
     return;
   enabled_ = true;
 
   MakeDatabaseAvailable();
 }
 
 void SafeBrowsingDatabaseManager::StopOnIOThread(bool shutdown) {
@@ skipping 506 matching lines @@
       new base::WeakPtrFactory<SafeBrowsingDatabaseManager>(this));
   checks_.insert(check);
 
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, task);
 
   base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManager::TimeoutCallback,
                  check->timeout_factory_->GetWeakPtr(), check),
       check_timeout_);
 }