Replace SafeBrowsing MAC with downloads over SSL.

chrome/browser/safe_browsing/safe_browsing_service.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/safe_browsing_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 41 matching lines @@
 using content::BrowserThread;
 using content::NavigationEntry;
 using content::WebContents;
 
 namespace {
 
 // Filename suffix for the cookie database.
 const FilePath::CharType kCookiesFile[] = FILE_PATH_LITERAL(" Cookies");
 
 // The default URL prefix where browser fetches chunk updates, hashes,
-// and reports safe browsing hits.
-const char* const kSbDefaultInfoURLPrefix =
-    "http://safebrowsing.clients.google.com/safebrowsing";
-
-// The default URL prefix where browser fetches MAC client key and reports
-// malware details.
-const char* const kSbDefaultMacKeyURLPrefix =
-    "https://sb-ssl.google.com/safebrowsing";
+// and reports safe browsing hits and malware details.
+const char* const kSbDefaultURLPrefix =
+    "https://safebrowsing.google.com/safebrowsing";
 
 // When download url check takes this long, client's callback will be called
 // without waiting for the result.
 const int64 kDownloadUrlCheckTimeoutMs = 10000;
 
 // Similar to kDownloadUrlCheckTimeoutMs, but for download hash checks.
 const int64 kDownloadHashCheckTimeoutMs = 10000;
 
 // Records disposition information about the check.  |hit| should be
 // |true| if there were any prefix hits in |full_hashes|.
@@ skipping 499 matching lines @@
 
     if (proceed) {
       BrowserThread::PostTask(
           BrowserThread::UI,
           FROM_HERE,
           base::Bind(&SafeBrowsingService::UpdateWhitelist, this, resource));
     }
   }
 }
 
-void SafeBrowsingService::OnNewMacKeys(const std::string& client_key,
-                                       const std::string& wrapped_key) {
-  PrefService* prefs = g_browser_process->local_state();
-  if (prefs) {
-    prefs->SetString(prefs::kSafeBrowsingClientKey, client_key);
-    prefs->SetString(prefs::kSafeBrowsingWrappedKey, wrapped_key);
-  }
-}
-
 net::URLRequestContextGetter* SafeBrowsingService::url_request_context() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return url_request_context_getter_.get();
 }
 
-// static
-void SafeBrowsingService::RegisterPrefs(PrefService* prefs) {
-  prefs->RegisterStringPref(prefs::kSafeBrowsingClientKey, "");
-  prefs->RegisterStringPref(prefs::kSafeBrowsingWrappedKey, "");
-}
-
 void SafeBrowsingService::ResetDatabase() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
       &SafeBrowsingService::OnResetDatabase, this));
 }
 
 void SafeBrowsingService::PurgeMemory() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   CloseDatabase();
@@ skipping 27 matching lines @@
   // Need to do the CheckForLeaks on IOThread instead of in ShutDown where
   // url_request_context_getter_ is cleared,  since the URLRequestContextGetter
   // will PostTask to IOTread to delete itself.
   using base::debug::LeakTracker;
   LeakTracker<SafeBrowsingURLRequestContextGetter>::CheckForLeaks();
 
   DCHECK(url_request_context_.get());
   url_request_context_ = NULL;
 }
 
-void SafeBrowsingService::StartOnIOThread(
-    const std::string& client_key,
-    const std::string& wrapped_key) {
+void SafeBrowsingService::StartOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (enabled_)
     return;
   DCHECK(!safe_browsing_thread_.get());
   safe_browsing_thread_.reset(new base::Thread("Chrome_SafeBrowsingThread"));
   if (!safe_browsing_thread_->Start())
     return;
   enabled_ = true;
 
   registrar_.reset(new content::NotificationRegistrar);
@@ skipping 10 matching lines @@
 #if defined(GOOGLE_CHROME_BUILD)
   std::string client_name("googlechrome");
 #else
   std::string client_name("chromium");
 #endif
 #endif
   CommandLine* cmdline = CommandLine::ForCurrentProcess();
   bool disable_auto_update =
       cmdline->HasSwitch(switches::kSbDisableAutoUpdate) ||
       cmdline->HasSwitch(switches::kDisableBackgroundNetworking);
-  std::string info_url_prefix =
-      cmdline->HasSwitch(switches::kSbInfoURLPrefix) ?
-      cmdline->GetSwitchValueASCII(switches::kSbInfoURLPrefix) :
-      kSbDefaultInfoURLPrefix;
-  std::string mackey_url_prefix =
-      cmdline->HasSwitch(switches::kSbMacKeyURLPrefix) ?
-      cmdline->GetSwitchValueASCII(switches::kSbMacKeyURLPrefix) :
-      kSbDefaultMacKeyURLPrefix;
+  std::string url_prefix =
+      cmdline->HasSwitch(switches::kSbURLPrefix) ?
+      cmdline->GetSwitchValueASCII(switches::kSbURLPrefix) :
+      kSbDefaultURLPrefix;
 
   DCHECK(!protocol_manager_);
   protocol_manager_ =
       SafeBrowsingProtocolManager::Create(this,
                                           client_name,
-                                          client_key,
-                                          wrapped_key,
                                           url_request_context_getter_,
-                                          info_url_prefix,
-                                          mackey_url_prefix,
+                                          url_prefix,
                                           disable_auto_update);
 
   protocol_manager_->Initialize();
 }
 
 void SafeBrowsingService::StopOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!enabled_)
     return;
 
@@ skipping 281 matching lines @@
 void SafeBrowsingService::DatabaseUpdateFinished(bool update_succeeded) {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   GetDatabase()->UpdateFinished(update_succeeded);
   DCHECK(database_update_in_progress_);
   database_update_in_progress_ = false;
 }
 
 void SafeBrowsingService::Start() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // Retrieve client MAC keys.
-  PrefService* local_state = g_browser_process->local_state();
-  DCHECK(local_state);
-  std::string client_key, wrapped_key;
-  if (local_state) {
-    client_key =
-      local_state->GetString(prefs::kSafeBrowsingClientKey);
-    wrapped_key =
-      local_state->GetString(prefs::kSafeBrowsingWrappedKey);
-  }
-
   CommandLine* cmdline = CommandLine::ForCurrentProcess();
   enable_download_protection_ =
       !cmdline->HasSwitch(switches::kSbDisableDownloadProtection);
 
   // We only download the csd-whitelist if client-side phishing detection is
   // enabled.
 #ifdef OS_CHROMEOS
   // Client-side detection is disabled on ChromeOS for now, so don't bother
   // downloading the whitelist.
   enable_csd_whitelist_ = false;
 #else
   enable_csd_whitelist_ =
       !cmdline->HasSwitch(switches::kDisableClientSidePhishingDetection);
 #endif
 
   // TODO(noelutz): remove this boolean variable since it should always be true
   // if SafeBrowsing is enabled.  Unfortunately, we have no test data for this
   // list right now.  This means that we need to be able to disable this list
   // for the SafeBrowsing test to pass.
   enable_download_whitelist_ = enable_csd_whitelist_;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&SafeBrowsingService::StartOnIOThread,
-                 this, client_key, wrapped_key));
+      base::Bind(&SafeBrowsingService::StartOnIOThread, this));
 }
 
 void SafeBrowsingService::Stop() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingService::StopOnIOThread, this));
 }
 
 void SafeBrowsingService::OnCloseDatabase() {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
@@ skipping 406 matching lines @@
     Stop();
 
   if (csd_service_.get())
     csd_service_->SetEnabledAndRefreshState(enable);
   if (download_service_.get()) {
     download_service_->SetEnabled(
         enable && !CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kDisableImprovedDownloadProtection));
   }
 }